chef 0.8.16 → 0.9.0.a3

data/lib/chef/resource/remote_file.rb

@@ -21,9 +21,9 @@ require 'chef/resource/file'
 class Chef
   class Resource
     class RemoteFile < Chef::Resource::File
-        
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :remote_file
         @action = "create"
         @source = ::File.basename(name)
@@ -54,6 +54,29 @@ class Chef
         )
       end
 
+      # The provider that should be used for this resource.
+      # === Returns:
+      # Chef::Provider::RemoteFile    when the source is an absolute URI, like
+      #                               http://www.google.com/robots.txt
+      # Chef::Provider::CookbookFile  when the source is a relative URI, like
+      #                               'myscript.pl', 'dir/config.conf'
+      def provider
+        if absolute_uri?(source)
+          Chef::Provider::RemoteFile
+        else
+          # contentious...
+          Chef::Log.warn("remote_file is deprecated for fetching files from cookbooks. Use cookbook_file instead")
+          Chef::Provider::CookbookFile
+        end
+      end
+
+      private
+      
+      def absolute_uri?(source)
+        URI.parse(source).absolute?
+      rescue URI::InvalidURIError
+        false
+      end
 
     end
   end

data/lib/chef/resource/route.rb

@@ -21,9 +21,9 @@ require 'chef/resource'
 class Chef
   class Resource
     class Route < Chef::Resource
-
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :route
         @target = name
         @action = :add

data/lib/chef/resource/ruby.rb

@@ -21,9 +21,9 @@ require 'chef/resource/script'
 class Chef
   class Resource
     class Ruby < Chef::Resource::Script
-        
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :ruby
         @interpreter = "ruby"
       end

data/lib/chef/resource/ruby_block.rb

@@ -20,8 +20,9 @@
 class Chef
   class Resource
     class RubyBlock < Chef::Resource
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :ruby_block
         @action = "create"
         @allowed_actions.push(:create)

data/lib/chef/resource/scm.rb

@@ -22,9 +22,9 @@ require 'chef/resource'
 class Chef
   class Resource
     class Scm < Chef::Resource
-
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @destination = name
         @resource_name = :scm
         @enable_submodules = false
@@ -92,6 +92,7 @@ class Chef
       end
 
       def svn_arguments(arg=nil)
+        @svn_arguments, arg = nil, nil if arg == false
         set_or_return(
           :svn_arguments,
           arg,
@@ -100,8 +101,9 @@ class Chef
       end
 
       def svn_info_args(arg=nil)
+        @svn_info_args, arg = nil, nil if arg == false
         set_or_return(
-          :svn_arguments,
+          :svn_info_args,
           arg,
           :kind_of => String)
       end
@@ -141,4 +143,4 @@ class Chef
 
     end
   end
-end
+end

data/lib/chef/resource/script.rb

@@ -21,9 +21,9 @@ require 'chef/resource/execute'
 class Chef
   class Resource
     class Script < Chef::Resource::Execute
-        
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :script
         @command = name
         @code = nil
@@ -48,4 +48,4 @@ class Chef
 
     end
   end
-end
+end

data/lib/chef/resource/service.rb

@@ -21,9 +21,9 @@ require 'chef/resource'
 class Chef
   class Resource
     class Service < Chef::Resource
-        
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :service
         @service_name = name
         @enabled = nil

data/lib/chef/resource/subversion.rb

@@ -22,8 +22,10 @@ class Chef
   class Resource
     class Subversion < Chef::Resource::Scm
       
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      def initialize(name, run_context=nil)
+        super
+        @svn_arguments = '--no-auth-cache'
+        @svn_info_args = '--no-auth-cache'
         @resource_name = :subversion
         @provider = Chef::Provider::Subversion
         allowed_actions << :force_export

data/lib/chef/resource/template.rb

@@ -21,9 +21,9 @@ require 'chef/resource/file'
 class Chef
   class Resource
     class Template < Chef::Resource::File
-        
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :template
         @action = "create"
         @source = "#{::File.basename(name)}.erb"

data/lib/chef/resource/user.rb

@@ -21,9 +21,9 @@ require 'chef/resource'
 class Chef
   class Resource
     class User < Chef::Resource
-        
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :user
         @username = name
         @comment = nil

data/lib/chef/resource/yum_package.rb

@@ -22,9 +22,9 @@ require 'chef/provider/package/yum'
 class Chef
   class Resource
     class YumPackage < Chef::Resource::Package
-        
-      def initialize(name, collection=nil, node=nil)
-        super(name, collection, node)
+      
+      def initialize(name, run_context=nil)
+        super
         @resource_name = :yum_package
         @provider = Chef::Provider::Package::Yum
       end

data/lib/chef/resource_collection.rb

@@ -120,16 +120,16 @@ class Chef
     # Find existing resources by searching the list of existing resources.  Possible
     # forms are:
     #
-    # resources(:file => "foobar")
-    # resources(:file => [ "foobar", "baz" ])
-    # resources("file[foobar]", "file[baz]")
-    # resources("file[foobar,baz]")
+    # find(:file => "foobar")
+    # find(:file => [ "foobar", "baz" ])
+    # find("file[foobar]", "file[baz]")
+    # find("file[foobar,baz]")
     #
     # Returns the matching resource, or an Array of matching resources. 
     #
     # Raises an ArgumentError if you feed it bad lookup information
     # Raises a Runtime Error if it can't find the resources you are looking for.
-    def resources(*args)
+    def find(*args)
       results = Array.new
       args.each do |arg|
         case arg
@@ -145,6 +145,10 @@ class Chef
       flat_results.length == 1 ? flat_results[0] : flat_results
     end
     
+    # resources is a poorly named, but we have to maintain it for back
+    # compat.
+    alias_method :resources, :find
+    
     # Serialize this object as a hash 
     def to_json(*a)
       instance_vars = Hash.new

data/lib/chef/resources.rb

@@ -19,6 +19,7 @@
 require 'chef/resource/apt_package'
 require 'chef/resource/bash'
 require 'chef/resource/breakpoint'
+require 'chef/resource/cookbook_file'
 require 'chef/resource/cron'
 require 'chef/resource/csh'
 require 'chef/resource/deploy'
@@ -26,6 +27,7 @@ require 'chef/resource/deploy_revision'
 require 'chef/resource/directory'
 require 'chef/resource/dpkg_package'
 require 'chef/resource/easy_install_package'
+require 'chef/resource/env'
 require 'chef/resource/erl_call'
 require 'chef/resource/execute'
 require 'chef/resource/file'

data/lib/chef/rest.rb

@@ -339,12 +339,16 @@ class Chef
       headers                 = @default_headers.merge(headers)
       headers['Accept']       = "application/json" unless raw
       headers["Content-Type"] = 'application/json' if json_body
+      headers['Content-Length'] = json_body.bytesize.to_s if json_body
       headers.merge!(authentication_headers(method, url, json_body)) if sign_requests?
       headers
     end
 
     def stream_to_tempfile(url, response)
       tf = Tempfile.open("chef-rest")
+      if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+        tf.binmode #required for binary files on Windows platforms
+      end
       Chef::Log.debug("Streaming download from #{url.to_s} to tempfile #{tf.path}")
       # Stolen from http://www.ruby-forum.com/topic/166423
       # Kudos to _why!

data/lib/chef/role.rb

@@ -275,6 +275,8 @@ class Chef
         role.name(name)
         role.from_file(rb_file)
         role
+      else
+        raise Chef::Exceptions::RoleNotFound, "Role '#{name}' could not be loaded from disk"
       end
     end
 

data/lib/chef/run_context.rb

@@ -0,0 +1,108 @@
+#
+# 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'
+
+# Value object that loads and tracks the context of a Chef run
+class Chef
+  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
+
+    # 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)
+      @node = node
+      @cookbook_collection = cookbook_collection
+      @resource_collection = Chef::ResourceCollection.new
+      @definitions = Hash.new
+      
+      # TODO: 5/18/2010 cw/timh - See note on Chef::Node's
+      # cookbook_collection attr_accessor
+      node.cookbook_collection = cookbook_collection
+
+      load
+    end
+
+    def load
+      foreach_cookbook_load_segment(:libraries) do |cookbook_name, filename|
+        Chef::Log.debug("Loading cookbook #{cookbook_name}'s library file: #{filename}")
+        require filename
+      end
+      
+      foreach_cookbook_load_segment(:providers) do |cookbook_name, filename|
+        Chef::Log.debug("Loading cookbook #{cookbook_name}'s providers from #{filename}")
+        Chef::Provider.build_from_file(cookbook_name, filename)
+      end
+      
+      foreach_cookbook_load_segment(:resources) do |cookbook_name, filename|
+        Chef::Log.debug("Loading cookbook #{cookbook_name}'s resources from #{filename}")
+        Chef::Resource.build_from_file(cookbook_name, filename)
+      end
+
+      node.load_attributes
+
+      foreach_cookbook_load_segment(:definitions) do |cookbook_name, filename|
+        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 found in #{filename}")
+          newval
+        end
+      end
+
+      # Retrieve the fully expanded list of recipes for the node by
+      # resolving roles; this step also merges attributes into the
+      # node from the roles/recipes included.
+      recipe_names = node.expand_node!
+      recipe_names.each do |recipe_name|
+        # 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_name)
+      end
+    end
+
+    private
+    
+    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

@@ -1,100 +1,109 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2009 Opscode, Inc.
+# 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.
 # 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/deep_merge'
+require 'chef/run_list/run_list_item'
+require 'chef/run_list/run_list_expansion'
 
 class Chef
   class RunList
     include Enumerable
 
-    attr_reader :recipes, :roles, :run_list
+    # @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 = Array.new
-      @recipes = Array.new
-      @roles = Array.new
-      @seen_roles = Array.new
-    end
-
-    def <<(item)
-      type, entry, fentry = parse_entry(item)
-      case type
-      when 'recipe'
-        @recipes << entry unless @recipes.include?(entry)
-      when 'role'
-        @roles << entry unless @roles.include?(entry)
-      end
-      @run_list << fentry unless @run_list.include?(fentry)
+      @run_list_items = Array.new
+    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 = run_list_item.kind_of?(RunListItem) ? run_list_item : parse_entry(run_list_item)
+      @run_list_items << run_list_item unless @run_list_items.include?(run_list_item)
       self
     end
 
-    def ==(*isequal)
-      check_array = nil
-      if isequal[0].kind_of?(Chef::RunList)
-        check_array = isequal[0].run_list
+    def ==(other)
+      if other.kind_of?(Chef::RunList)
+        other.run_list_items == @run_list_items
       else
-        check_array = isequal.flatten
-      end
-      
-      return false if check_array.length != @run_list.length
+        other_run_list_items = other
+        return false unless other_run_list_items.size == @run_list_items.size
 
-      check_array.each_index do |i|
-        to_check = check_array[i]
-        type, name, fname = parse_entry(to_check)
-        return false if @run_list[i] != fname
+        other_run_list_items.map! { |item| item.kind_of?(RunListItem) ? item : RunListItem.new(item) }
+        other_run_list_items == @run_list_items
       end
-
-      true
     end
 
     def to_s
-      @run_list.join(", ")
+      @run_list_items.join(", ")
     end
 
     def empty?
-      @run_list.length == 0 ? true : false
+      @run_list_items.length == 0 ? true : false
     end
 
     def [](pos)
-      @run_list[pos]
+      @run_list_items[pos]
     end
 
     def []=(pos, item)
-      type, entry, fentry = parse_entry(item)
-      @run_list[pos] = fentry 
+      @run_list_items[pos] = parse_entry(item)
     end
 
     def each(&block)
-      @run_list.each { |i| block.call(i) }
+      @run_list_items.each { |i| block.call(i) }
     end
 
     def each_index(&block)
-      @run_list.each_index { |i| block.call(i) }
+      @run_list_items.each_index { |i| block.call(i) }
     end
 
     def include?(item)
-      type, entry, fentry = parse_entry(item)
-      @run_list.include?(fentry)
+      @run_list_items.include?(parse_entry(item))
     end
 
     def reset!(*args)
-      @run_list = Array.new
-      @recipes = Array.new
-      @roles = Array.new
+      @run_list_items.clear
       args.flatten.each do |item|
         if item.kind_of?(Chef::RunList)
           item.each { |r| self << r }
@@ -106,65 +115,33 @@ class Chef
     end
 
     def remove(item)
-      type, entry, fentry = parse_entry(item)
-      @run_list.delete_if { |i| i == fentry }
-      if type == "recipe"
-        @recipes.delete_if { |i| i == entry }
-      elsif type == "role"
-        @roles.delete_if { |i| i == entry }
-      end
+      @run_list_items.delete_if{|i| i == item}
       self
     end
 
-    def expand(from='server', couchdb=nil, rest=nil)
+    def expand(data_source='server', couchdb=nil, rest=nil)
       couchdb = couchdb ? couchdb : Chef::CouchDB.new
-      recipes = Array.new
-      default_attrs = Mash.new
-      override_attrs = Mash.new
-      
-      @run_list.each do |entry|
-        type, name, fname = parse_entry(entry)
-        case type
-        when 'recipe'
-          recipes << name unless recipes.include?(name)
-        when 'role'
-          role = begin
-                   next if @seen_roles.include?(name)
-                   @seen_roles << name
-                   if from == 'disk' || Chef::Config[:solo]
-                     # Load the role from disk
-                     Chef::Role.from_disk("#{name}") || raise(Chef::Exceptions::RoleNotFound)
-                   elsif from == 'server'
-                     # Load the role from the server
-                     begin
-                       (rest || Chef::REST.new(Chef::Config[:role_url])).get_rest("roles/#{name}") 
-                     rescue Net::HTTPServerException
-                       raise Chef::Exceptions::RoleNotFound if $!.message == '404 "Not Found"'
-                       raise
-                     end
-                   elsif from == 'couchdb'
-                     # Load the role from couchdb
-                     Chef::Role.cdb_load(name, couchdb) rescue Chef::Exceptions::CouchDBNotFound raise(Chef::Exceptions::RoleNotFound)
-                   end
-                 rescue Chef::Exceptions::RoleNotFound
-                   Chef::Log.error("Role #{name} is in the runlist but does not exist. Skipping expand.")
-                   next
-                 end
-          rec, d, o = role.run_list.expand(from, couchdb, rest)
-          rec.each { |r| recipes <<  r unless recipes.include?(r) }
-          default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, Chef::Mixin::DeepMerge.merge(role.default_attributes,d))
-          override_attrs = Chef::Mixin::DeepMerge.merge(override_attrs, Chef::Mixin::DeepMerge.merge(role.override_attributes, o))
-        end
-      end
-      return recipes, default_attrs, override_attrs
+
+      expansion = expansion_for_data_source(data_source, :couchdb => couchdb, :rest => rest)
+      expansion.expand
+      return expansion.recipes, expansion.default_attrs, expansion.override_attrs
     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)
-      case entry 
-      when /^(.+)\[(.+)\]$/
-        [ $1, $2, entry ]
-      else
-        [ 'recipe', entry, "recipe[#{entry}]" ]
+      RunListItem.new(entry)
+    end
+
+    def expansion_for_data_source(data_source, opts={})
+      data_source = 'disk' if Chef::Config[:solo]
+      case data_source.to_s
+      when 'disk'
+        RunListExpansionFromDisk.new(@run_list_items)
+      when 'server'
+        RunListExpansionFromAPI.new(@run_list_items, opts[:rest])
+      when 'couchdb'
+        RunListExpansionFromCouchDB.new(@run_list_items, opts[:couchdb])
       end
     end