chef 0.7.16 → 0.8.2

data/lib/chef/compile.rb

@@ -22,11 +22,14 @@ require 'chef/node'
 require 'chef/role'
 require 'chef/log'
 require 'chef/mixin/deep_merge'
+require 'chef/mixin/language_include_recipe'
 
 class Chef
   class Compile
       
     attr_accessor :node, :cookbook_loader, :collection, :definitions
+
+    include Chef::Mixin::LanguageIncludeRecipe
     
     # Creates a new Chef::Compile object and populates its fields. This object gets
     # used by the Chef Server to generate a fully compiled recipe list for a node.
@@ -36,11 +39,12 @@ class Chef
     def initialize(node=nil)
       @node = node 
       @cookbook_loader = Chef::CookbookLoader.new
+      @node.cookbook_loader = @cookbook_loader
       @collection = Chef::ResourceCollection.new
       @definitions = Hash.new
       @recipes = Array.new
-      @default_attributes = Array.new
-      @override_attributes = Array.new
+      @default_attributes = Hash.new 
+      @override_attributes = Hash.new
 
       load_libraries
       load_providers
@@ -70,8 +74,6 @@ class Chef
     # === Returns
     # true:: Always returns true
     def load_attributes()
-      recipes, default_attrs, override_attrs = expand_node
-
       @cookbook_loader.each do |cookbook|
         cookbook.load_attributes(@node)
       end
@@ -140,29 +142,15 @@ class Chef
     def load_recipes
       expand_node
       @recipes.each do |recipe|
-        if @node.run_state[:seen_recipes].has_key?(recipe)
-          Chef::Log.debug("I am not loading #{recipe}, because I have already seen it.")
-          next
-        end
-        Chef::Log.debug("Loading Recipe #{recipe}")
-        @node.run_state[:seen_recipes][recipe] = true
-
-        rmatch = recipe.match(/(.+?)::(.+)/)
-        if rmatch
-         cookbook = @cookbook_loader[rmatch[1]]
-         cookbook.load_recipe(rmatch[2], @node, @collection, @definitions, @cookbook_loader)
-        else
-         cookbook = @cookbook_loader[recipe]
-         cookbook.load_recipe("default", @node, @collection, @definitions, @cookbook_loader)
-        end
+        include_recipe(recipe)
       end
       true
     end
 
     def expand_node
       @recipes, @default_attributes, @override_attributes = @node.run_list.expand
-      @node.default = @default_attributes
-      @node.override = @override_attributes
+      @node.default_attrs = Chef::Mixin::DeepMerge.merge(@node.default_attrs, @default_attributes)
+      @node.override_attrs = Chef::Mixin::DeepMerge.merge(@node.override_attrs, @override_attributes)
       return @recipes, @default_attributes, @override_attributes
     end
     

data/lib/chef/config.rb

@@ -17,6 +17,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'chef/log'
 require 'mixlib/config'
 
 class Chef
@@ -54,13 +55,24 @@ class Chef
           :template_url,
           :remotefile_url,
           :search_url,
+          :chef_server_url,
           :role_url ].each do |u| 
             c[u] = url
         end
       end
       url
     end
-    
+
+    # When you are using ActiveSupport, they monkey-patch 'daemonize' into Kernel.  
+    # So while this is basically identical to what method_missing would do, we pull
+    # it up here and get a real method written so that things get dispatched 
+    # properly.
+    config_attr_writer :daemonize do |v|
+      configure do |c|
+        c[:daemonize] = v
+      end
+    end
+
     # Override the config dispatch to set the value of log_location configuration option
     #
     # === Parameters
@@ -70,7 +82,9 @@ class Chef
       if location.respond_to? :sync=
         location
       elsif location.respond_to? :to_str
-        File.new(location.to_str, "a")
+        f = File.new(location.to_str, "a")
+        f.sync = true
+        f
       end
     end
 
@@ -86,16 +100,16 @@ class Chef
 
     authorized_openid_identifiers nil
     authorized_openid_providers nil
-    chef_server_url nil
-    cookbook_path [ "/var/chef/site-cookbooks", "/var/chef/cookbooks" ]
+    client_registration_retries 5
+    cookbook_path [ "/var/chef/cookbooks", "/var/chef/site-cookbooks" ]
+    cookbook_tarball_path "/var/chef/cookbook-tarballs"
     couchdb_database "chef"
     couchdb_url "http://localhost:5984"
     couchdb_version nil
-    daemonize nil
     delay 0
     executable_path ENV['PATH'] ? ENV['PATH'].split(File::PATH_SEPARATOR) : []
     file_cache_path "/var/chef/cache"
-    file_store_path "/var/chef/store"
+    file_backup_path nil
     group nil
     http_retry_count 5
     http_retry_delay 5
@@ -103,10 +117,11 @@ class Chef
     json_attribs nil
     log_level :info
     log_location STDOUT
+    verbose_logging nil
     node_name nil
     node_path "/var/chef/node"
     openid_cstore_couchdb false
-    openid_cstore_path "/var/chef/openid/cstore"
+    openid_cstore_path "/var/chef/openid/cstore"    
     openid_providers nil
     openid_store_couchdb false
     openid_store_path "/var/chef/openid/db"
@@ -118,19 +133,21 @@ class Chef
     queue_retry_count 5
     queue_retry_delay 5
     queue_user ""
-    queue_prefix nil
+    chef_server_url "http://localhost:4000"
     registration_url "http://localhost:4000"
+    client_url "http://localhost:4042"
     remotefile_url "http://localhost:4000"
-    rest_timeout 60
+    rest_timeout 300
     run_command_stderr_timeout 120
     run_command_stdout_timeout 120
-    search_index_path "/var/chef/search_index"
     search_url "http://localhost:4000"
     solo  false
     splay nil
     ssl_client_cert ""
     ssl_client_key ""
     ssl_verify_mode :verify_none
+    ssl_ca_path nil
+    ssl_ca_file nil
     template_url "http://localhost:4000"
     umask 0022
     user nil
@@ -138,5 +155,45 @@ class Chef
     role_path "/var/chef/roles"
     role_url "http://localhost:4000"
     recipe_url nil
+    solr_url "http://localhost:8983"
+    solr_jetty_path "/var/chef/solr-jetty"
+    solr_data_path "/var/chef/solr/data"
+    solr_home_path "/var/chef/solr"
+    solr_heap_size "256M"
+    solr_java_opts nil
+    amqp_host '0.0.0.0'
+    amqp_port '5672'
+    amqp_user 'chef'
+    amqp_pass 'testing'
+    amqp_vhost '/chef'
+    # Setting this to a UUID string also makes the queue durable 
+    # (persist across rabbitmq restarts)
+    amqp_consumer_id nil
+
+    client_key "/etc/chef/client.pem"
+    validation_key "/etc/chef/validation.pem"
+    validation_client_name "chef-validator"
+    web_ui_client_name "chef-webui"
+    web_ui_key "/etc/chef/webui.pem"
+    web_ui_admin_user_name  "admin"
+    web_ui_admin_default_password "p@ssw0rd1"
+
+    # Server Signing CA
+    #
+    # In truth, these don't even have to change
+    signing_ca_cert "/var/chef/ca/cert.pem"
+    signing_ca_key "/var/chef/ca/key.pem"
+    signing_ca_country "US"
+    signing_ca_state "Washington"
+    signing_ca_location "Seattle"
+    signing_ca_org "Chef User"
+    signing_ca_domain "opensource.opscode.com"
+    signing_ca_email "opensource-cert@opscode.com"
+
+    # Checksum Cache
+    # Uses Moneta on the back-end
+    cache_type "BasicFile"
+    cache_options({ :path => "/var/chef/cache/checksums", :skip_expires => true })
+
   end
 end

data/lib/chef/cookbook.rb

@@ -1,5 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
 # Author:: Christopher Walters (<cw@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
@@ -26,9 +27,9 @@ class Chef
   class Cookbook
     include Chef::Mixin::ConvertToClassName
     
-    attr_accessor :attribute_files, :definition_files, :template_files, :remote_files, 
+    attr_accessor :definition_files, :template_files, :remote_files, 
                   :lib_files, :resource_files, :provider_files, :name
-    attr_reader :recipe_files
+    attr_reader :recipe_files, :attribute_files
     
     # Creates a new Chef::Cookbook object.  
     #
@@ -37,6 +38,7 @@ class Chef
     def initialize(name)
       @name = name
       @attribute_files = Array.new
+      @attribute_names = Hash.new
       @definition_files = Array.new
       @template_files = Array.new
       @remote_files = Array.new
@@ -70,15 +72,23 @@ class Chef
     # === Raises
     # <ArgumentError>:: If the argument is not a kind_of? <Chef::Node>
     def load_attributes(node)
-      unless node.kind_of?(Chef::Node)
-        raise ArgumentError, "You must pass a Chef::Node to load_attributes!"
-      end
       @attribute_files.each do |file|
-        Chef::Log.debug("Loading attributes from #{file}")
-        node.from_file(file)
+        load_attribute_file(file, node)
       end
       node
     end
+
+    def load_attribute_file(file, node)
+      Chef::Log.debug("Loading attributes from #{file}")
+      node.from_file(file)
+    end
+
+    def load_attribute(name, node)
+      attr_name = shorten_name(name)
+      file = @attribute_files[@attribute_names[attr_name]]
+      load_attribute_file(file, node)
+      node
+    end
     
     # Loads all the resource definitions in this cookbook.
     #
@@ -118,20 +128,14 @@ class Chef
     end
     
     def recipe_files=(*args)
-      @recipe_files = args.flatten
-      @recipe_files.each_index do |i|
-        file = @recipe_files[i]
-        case file
-        when /(.+\/)(.+).rb$/
-          @recipe_names[$2] = i
-        when /(.+).rb$/
-          @recipe_names[$1] = i
-        else  
-          @recipe_names[file] = i
-        end
-      end
+      @recipe_files, @recipe_names = set_with_names(args.flatten)
       @recipe_files
     end
+
+    def attribute_files=(*args)
+      @attribute_files, @attribute_names = set_with_names(args.flatten)
+      @attribute_files
+    end
     
     def recipe?(name)
       lookup_name = name
@@ -153,9 +157,7 @@ class Chef
     
     def load_recipe(name, node, collection=nil, definitions=nil, cookbook_loader=nil)
       cookbook_name = @name
-      recipe_name = nil
-      nmatch = name.match(/^(.+?)::(.+)$/)
-      recipe_name = nmatch ? nmatch[2] : name
+      recipe_name = shorten_name(name) 
       
       unless @recipe_names.has_key?(recipe_name)
         raise ArgumentError, "Cannot find a recipe matching #{recipe_name} in cookbook #{@name}"
@@ -166,6 +168,31 @@ class Chef
       recipe.from_file(@recipe_files[@recipe_names[recipe_name]])
       recipe
     end
+
+    private
+
+      def shorten_name(name)
+        short_name = nil
+        nmatch = name.match(/^(.+?)::(.+)$/)
+        short_name = nmatch ? nmatch[2] : name
+      end
+
+      def set_with_names(file_list)
+        files = file_list
+        names = Hash.new
+        files.each_index do |i|
+          file = files[i]
+          case file
+          when /(.+\/)(.+).rb$/
+            names[$2] = i
+          when /(.+).rb$/
+            names[$1] = i
+          else  
+            names[file] = i
+          end
+        end
+        [ files, names ]
+      end
     
   end
 end

data/lib/chef/cookbook/metadata.rb

@@ -40,6 +40,7 @@ class Chef
                     :providing,
                     :replacing,
                     :attributes,
+                    :groupings,
                     :recipes,
                     :version
 
@@ -69,6 +70,7 @@ class Chef
         @providing = Mash.new
         @replacing = Mash.new
         @attributes = Mash.new
+        @groupings = Mash.new
         @recipes = Mash.new
         @version = Version.new "0.0.0"
         if cookbook
@@ -307,9 +309,10 @@ class Chef
       #
       #   display_name<String>:: What a UI should show for this attribute
       #   description<String>:: A hint as to what this attr is for
-      #   multiple_values<True>,<False>:: Whether it supports multiple values
-      #   type<String>:: "string", "hash" or "array" - default is "string"
-      #   required<True>,<False>:: Whether this attr is required - default false
+      #   choice<Array>:: An array of choices to present to the user.
+      #   calculated<Boolean>:: If true, the default value is calculated by the recipe and cannot be displayed.
+      #   type<String>:: "string" or "array" - default is "string"  ("hash" is supported for backwards compatibility)
+      #   required<String>:: Whether this attr is 'required', 'recommended' or 'optional' - default 'optional' (true/false values also supported for backwards compatibility)
       #   recipes<Array>:: An array of recipes which need this attr set.
       #   default<String>,<Array>,<Hash>:: The default value
       #
@@ -325,17 +328,35 @@ class Chef
           {
             :display_name => { :kind_of => String },
             :description => { :kind_of => String },
-            :multiple_values => { :equal_to => [ true, false ], :default => false },
+            :choice => { :kind_of => [ Array ], :default => [] },
+            :calculated => { :equal_to => [ true, false ], :default => false },
             :type => { :equal_to => [ "string", "array", "hash" ], :default => "string" },
-            :required => { :equal_to => [ true, false ], :default => false },
+            :required => { :equal_to => [ "required", "recommended", "optional", true, false ], :default => "optional" },
             :recipes => { :kind_of => [ Array ], :default => [] },
             :default => { :kind_of => [ String, Array, Hash ] }
           }
         )
+        options[:required] = remap_required_attribute(options[:required]) unless options[:required].nil?
+        validate_string_array(options[:choice])
+        validate_calculated_default_rule(options)
+        validate_choice_default_rule(options)
+
         @attributes[name] = options 
         @attributes[name]
       end
 
+      def grouping(name, options)
+        validate(
+          options,
+          {
+            :title => { :kind_of => String },
+            :description => { :kind_of => String }
+          }
+        )
+        @groupings[name] = options 
+        @groupings[name]
+      end
+
       def _check_version_expression(version_string)
         if version_string =~ /^(>>|>=|=|<=|<<) (.+)$/
           [ $1, $2 ]
@@ -360,6 +381,7 @@ class Chef
           :providing => self.providing,
           :replacing => self.replacing,
           :attributes => self.attributes,
+          :groupings => self.groupings,
           :recipes => self.recipes,
           :version => self.version
         }
@@ -379,6 +401,7 @@ class Chef
         self.maintainer o['maintainer'] if o.has_key?('maintainer')
         self.maintainer_email o['maintainer_email'] if o.has_key?('maintainer_email')
         self.license o['license'] if o.has_key?('license')
+        self.version o['version'] if o.has_key?('version')
         self.platforms = o['platforms'] if o.has_key?('platforms')
         self.dependencies = o['dependencies'] if o.has_key?('dependencies')
         self.recommendations = o['recommendations'] if o.has_key?('recommendations')
@@ -387,6 +410,7 @@ class Chef
         self.providing = o['providing'] if o.has_key?('providing')
         self.replacing = o['replacing'] if o.has_key?('replacing')
         self.attributes = o['attributes'] if o.has_key?('attributes')
+        self.groupings = o['groupings'] if o.has_key?('groupings')
         self.recipes = o['recipes'] if o.has_key?('recipes')
         self.version = o['version'] if o.has_key?('version')
         self
@@ -402,6 +426,62 @@ class Chef
         from_hash(o)
       end
 
+    private
+
+      # Verify that the given array is an array of strings
+      #
+      # Raise an exception if the members of the array are not Strings
+      #
+      # === Parameters
+      # arry<Array>:: An array to be validated
+      def validate_string_array(arry)
+        if arry.kind_of?(Array)
+          arry.each do |choice|
+            validate( {:choice => choice}, {:choice => {:kind_of => String}} )
+          end
+        end
+      end
+
+      # For backwards compatibility, remap Boolean values to String
+      #   true is mapped to "required"
+      #   false is mapped to "optional"
+      #
+      # === Parameters
+      # required_attr<String><Boolean>:: The value of options[:required]
+      #
+      # === Returns
+      # required_attr<String>:: "required", "recommended", or "optional"
+      def remap_required_attribute(value)
+        case value
+        when true
+          value = "required"
+        when false
+          value = "optional"
+        end
+        value
+      end
+
+      def validate_calculated_default_rule(options)
+        calculated_conflict = ((options[:default].is_a?(Array) && !options[:default].empty?) ||
+                               (options[:default].is_a?(String) && !options[:default] != "")) &&
+                              options[:calculated] == true
+        raise ArgumentError, "Default cannot be specified if calculated is true!" if calculated_conflict
+      end
+
+      def validate_choice_default_rule(options)
+        return if !options[:choice].is_a?(Array) || options[:choice].empty?
+
+        if options[:default].is_a?(String) && options[:default] != ""
+          raise ArgumentError, "Default must be one of your choice values!" if options[:choice].index(options[:default]) == nil
+        end
+
+        if options[:default].is_a?(Array) && !options[:default].empty?
+          options[:default].each do |val|
+            raise ArgumentError, "Default values must be a subset of your choice values!" if options[:choice].index(val) == nil
+          end
+        end
+      end
+
     end
   end
 end