chef 0.10.8 → 0.10.10.beta.1

data/lib/chef/rest/auth_credentials.rb

@@ -21,6 +21,7 @@
 # limitations under the License.
 #
 require 'chef/exceptions'
+require 'chef/log'
 require 'mixlib/authentication/signedheaderauth'
 
 class Chef

data/lib/chef/rest/rest_request.rb

@@ -44,6 +44,21 @@ class Chef
       UA_COMMON = "/#{::Chef::VERSION} (#{engine}-#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}; ohai-#{Ohai::VERSION}; #{RUBY_PLATFORM}; +http://opscode.com)"
       DEFAULT_UA = "Chef Client" << UA_COMMON
 
+      USER_AGENT = "User-Agent".freeze
+
+      ACCEPT_ENCODING = "Accept-Encoding".freeze
+      ENCODING_GZIP_DEFLATE = "gzip;q=1.0,deflate;q=0.6,identity;q=0.3".freeze
+
+      GET     = "get".freeze
+      PUT     = "put".freeze
+      POST    = "post".freeze
+      DELETE  = "delete".freeze
+      HEAD    = "head".freeze
+
+      HTTPS = "https".freeze
+
+      SLASH = "/".freeze
+
       def self.user_agent=(ua)
         @user_agent = ua
       end
@@ -76,7 +91,7 @@ class Chef
       end
 
       def path
-        @url.path.empty? ? "/" : @url.path
+        @url.path.empty? ? SLASH : @url.path
       end
 
       def call
@@ -121,6 +136,7 @@ class Chef
         # TODO: need to set accept somewhere else
         # headers.merge!('Accept' => "application/json") unless raw
         @headers['X-Chef-Version'] = ::Chef::VERSION
+        @headers[ACCEPT_ENCODING] = ENCODING_GZIP_DEFLATE
 
         if @cookies.has_key?("#{host}:#{port}")
           @headers['Cookie'] = @cookies["#{host}:#{port}"]
@@ -146,7 +162,7 @@ class Chef
           pass = Chef::Config["#{url.scheme}_proxy_pass"]
           @http_client = Net::HTTP.Proxy(http_proxy.host, http_proxy.port, user, pass).new(host, port)
         end
-        if url.scheme == "https"
+        if url.scheme == HTTPS
           @http_client.use_ssl = true
           if config[:ssl_verify_mode] == :verify_none
             @http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
@@ -188,15 +204,15 @@ class Chef
         req_path << "?#{query}" if query
 
         @http_request = case method.to_s.downcase
-        when "get"
+        when GET
           Net::HTTP::Get.new(req_path, headers)
-        when "post"
+        when POST
           Net::HTTP::Post.new(req_path, headers)
-        when "put"
+        when PUT
           Net::HTTP::Put.new(req_path, headers)
-        when "delete"
+        when DELETE
           Net::HTTP::Delete.new(req_path, headers)
-        when "head"
+        when HEAD
           Net::HTTP::Head.new(req_path, headers)
         else
           raise ArgumentError, "You must provide :GET, :PUT, :POST, :DELETE or :HEAD as the method"
@@ -205,7 +221,7 @@ class Chef
         @http_request.body = request_body if (request_body && @http_request.request_body_permitted?)
         # Optionally handle HTTP Basic Authentication
         @http_request.basic_auth(url.user, url.password) if url.user
-        @http_request['User-Agent'] = self.class.user_agent
+        @http_request[USER_AGENT] = self.class.user_agent
       end
 
     end

data/lib/chef/role.rb

@@ -168,8 +168,14 @@ class Chef
         "default_attributes" => @default_attributes,
         "override_attributes" => @override_attributes,
         "chef_type" => "role",
-        "run_list" => run_list,
-        "env_run_lists" => env_run_lists_without_default
+
+        #Render to_json correctly for run_list items (both run_list and evn_run_lists)
+        #so malformed json does not result
+        "run_list" => run_list.run_list.map { |item| item.to_s },
+        "env_run_lists" => env_run_lists_without_default.inject({}) do |accumulator, (k, v)|
+          accumulator[k] = v.map { |x| x.to_s }
+          accumulator
+        end
       }
       result["_rev"] = couchdb_rev if couchdb_rev
       result

data/lib/chef/run_list.rb

@@ -85,7 +85,7 @@ class Chef
     end
 
     def to_json(*args)
-      to_a.to_json(*args)
+      to_a.map { |item| item.to_s}.to_json(*args)
     end
 
     def empty?

data/lib/chef/run_list/run_list_expansion.rb

@@ -90,8 +90,8 @@ class Chef
       end
 
       def apply_role_attributes(role)
-        @default_attrs = Chef::Mixin::DeepMerge.merge(@default_attrs, role.default_attributes)
-        @override_attrs = Chef::Mixin::DeepMerge.merge(@override_attrs, role.override_attributes)
+        @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)

data/lib/chef/run_list/run_list_item.rb

@@ -21,6 +21,7 @@ class Chef
       QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}
       QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}
       VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}
+      FALSE_FRIEND                 = %r{[\[\]]}
 
       attr_reader :name, :type, :version
 
@@ -51,6 +52,12 @@ class Chef
             @type = :recipe
             @name = match[1]
             @version = match[3] if match[3]
+          elsif match = FALSE_FRIEND.match(item)
+            # Recipe[recipe_name]
+            # roles[role_name]
+            name = match[1]
+            raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be recipe[#{name}] or role[#{name}]"
+
           else
             # recipe_name
             @type = :recipe

data/lib/chef/runner.rb

@@ -42,6 +42,10 @@ class Chef
     # Determine the appropriate provider for the given resource, then
     # execute it.
     def run_action(resource, action)
+      # Try to resolve lazy/forward references in notifications again to handle
+      # the case where the resource was defined lazily (ie. in a ruby_block)
+      resource.resolve_notification_references
+
       resource.run_action(action)
 
       # Execute any immediate and queue up any delayed notifications

data/lib/chef/shef.rb

@@ -144,7 +144,7 @@ module Shef
 
   def self.greeting
     " #{Etc.getlogin}@#{Shef.session.node.fqdn}"
-  rescue NameError
+  rescue NameError, ArgumentError
     ""
   end
 
@@ -303,7 +303,7 @@ FOOTER
     def config_file_for_shef_mode(environment)
       if config[:config_file]
         config[:config_file]
-      elsif environment
+      elsif environment && ENV['HOME']
         Shef.env = environment
         config_file_to_try = ::File.join(ENV['HOME'], '.chef', environment, 'shef.rb')
         unless ::File.exist?(config_file_to_try)

data/lib/chef/shef/shef_session.rb

@@ -229,13 +229,13 @@ module Shef
     # attributes, and does not save updates to the server
     def build_node
       Chef::Log.debug("Building node object for #{@node_name}")
-
       @node = Chef::Node.find_or_create(node_name)
-
       ohai_data = @ohai.data.merge(@node.automatic_attrs)
-
       @node.consume_external_attrs(ohai_data,nil)
-
+      @run_list_expansion = @node.expand!('server')
+      @expanded_run_list_with_versions = @run_list_expansion.recipes.with_version_constraints_strings
+      Chef::Log.info("Run List is [#{@node.run_list}]")
+      Chef::Log.info("Run List expands to [#{@expanded_run_list_with_versions.join(', ')}]")
       @node
     end
 
@@ -276,7 +276,6 @@ module Shef
       @client.run_ohai
       @client.register
       @client.build_node
-
       @client.sync_cookbooks
     end
 

data/lib/chef/shell_out.rb

@@ -1,249 +1,6 @@
-#--
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 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 'etc'
-require 'tmpdir'
-require 'chef/log'
-require 'fcntl'
-require 'chef/exceptions'
+require 'mixlib/shellout'
 
 class Chef
-
-  # == Chef::ShellOut
-  # Provides a simplified interface to shelling out yet still collecting both
-  # standard out and standard error and providing full control over environment,
-  # working directory, uid, gid, etc.
-  #
-  # No means for passing input to the subprocess is provided, nor is there any
-  # way to inspect the output of the command as it is being read. If you need
-  # to do that, you have to use popen4 (in Chef::Mixin::Command)
-  #
-  # === Platform Support
-  # Chef::ShellOut uses Kernel.fork() and is therefore unsuitable for Windows
-  # or jruby.
-  class ShellOut
-    READ_WAIT_TIME = 0.01
-    READ_SIZE = 4096
-    DEFAULT_READ_TIMEOUT = 600
-    DEFAULT_ENVIRONMENT = {'LC_ALL' => 'C'}
-
-    if RUBY_PLATFORM =~ /mswin|mingw32|windows/
-      require 'chef/shell_out/windows'
-      include ShellOut::Windows
-    else
-      require 'chef/shell_out/unix'
-      include ShellOut::Unix
-    end
-
-    attr_accessor :user
-    attr_accessor :group
-    attr_accessor :cwd
-    attr_accessor :valid_exit_codes
-    attr_accessor :live_stream
-    attr_accessor :command_log_level
-    attr_accessor :command_log_prepend
-
-    attr_reader :command, :umask, :environment
-    attr_writer :timeout
-    attr_reader :execution_time
-
-    attr_reader :stdout, :stderr, :status
-
-    attr_reader :stdin_pipe, :stdout_pipe, :stderr_pipe, :process_status_pipe
-
-    # === Arguments:
-    # Takes a single command, or a list of command fragments. These are used
-    # as arguments to Kernel.exec. See the Kernel.exec documentation for more
-    # explanation of how arguments are evaluated. The last argument can be an
-    # options Hash.
-    # === Options:
-    # If the last argument is a Hash, it is removed from the list of args passed
-    # to exec and used as an options hash. The following options are available:
-    # * +user+: the user the commmand should run as. if an integer is given, it is
-    #   used as a uid. A string is treated as a username and resolved to a uid
-    #   with Etc.getpwnam
-    # * +group+: the group the command should run as. works similarly to +user+
-    # * +cwd+: the directory to chdir to before running the command
-    # * +umask+: a umask to set before running the command. If given as an Integer,
-    #   be sure to use two leading zeros so it's parsed as Octal. A string will
-    #   be treated as an octal integer
-    # * +returns+:  one or more Integer values to use as valid exit codes for the
-    #   subprocess. This only has an effect if you call +error!+ after
-    #   +run_command+.
-    # * +environment+: a Hash of environment variables to set before the command
-    #   is run. By default, the environment will *always* be set to 'LC_ALL' => 'C'
-    #   to prevent issues with multibyte characters in Ruby 1.8. To avoid this,
-    #   use :environment => nil for *no* extra environment settings, or
-    #   :environment => {'LC_ALL'=>nil, ...} to set other environment settings
-    #   without changing the locale.
-    # * +timeout+: a Numeric value for the number of seconds to wait on the
-    #   child process before raising an Exception. This is calculated as the
-    #   total amount of time that ShellOut waited on the child process without
-    #   receiving any output (i.e., IO.select returned nil). Default is 60
-    #   seconds. Note: the stdlib Timeout library is not used.
-    # === Examples:
-    # Invoke find(1) to search for .rb files:
-    #   find = Chef::ShellOut.new("find . -name '*.rb'")
-    #   find.run_command
-    #   # If all went well, the results are on +stdout+
-    #   puts find.stdout
-    #   # find(1) prints diagnostic info to STDERR:
-    #   puts "error messages" + find.stderr
-    #   # Raise an exception if it didn't exit with 0
-    #   find.error!
-    # Run a command as the +www+ user with no extra ENV settings from +/tmp+
-    #   cmd = Chef::ShellOut.new("apachectl", "start", :user => 'www', :env => nil, :cwd => '/tmp')
-    #   cmd.run_command # etc.
-    def initialize(*command_args)
-      @stdout, @stderr = '', ''
-      @live_stream = nil
-      @command_log_level = :debug
-      @command_log_prepend = nil 
-      @environment = DEFAULT_ENVIRONMENT
-      @cwd = nil
-      @valid_exit_codes = [0]
-
-      if command_args.last.is_a?(Hash)
-        parse_options(command_args.pop)
-      end
-
-      @command = command_args.size == 1 ? command_args.first : command_args
-    end
-
-    def umask=(new_umask)
-      @umask = (new_umask.respond_to?(:oct) ? new_umask.oct : new_umask.to_i) & 007777
-    end
-
-    def uid
-      return nil unless user
-      user.kind_of?(Integer) ? user : Etc.getpwnam(user.to_s).uid
-    end
-
-    def gid
-      return nil unless group
-      group.kind_of?(Integer) ? group : Etc.getgrnam(group.to_s).gid
-    end
-
-    def timeout
-      @timeout || DEFAULT_READ_TIMEOUT
-    end
-
-    # Creates a String showing the output of the command, including a banner
-    # showing the exact command executed. Used by +invalid!+ to show command
-    # results when the command exited with an unexpected status.
-    def format_for_exception
-      msg = ""
-      msg << "---- Begin output of #{command} ----\n"
-      msg << "STDOUT: #{stdout.strip}\n"
-      msg << "STDERR: #{stderr.strip}\n"
-      msg << "---- End output of #{command} ----\n"
-      msg << "Ran #{command} returned #{status.exitstatus}" if status
-      msg
-    end
-
-    def exitstatus
-      @status && @status.exitstatus
-    end
-
-    # Run the command, writing the command's standard out and standard error
-    # to +stdout+ and +stderr+, and saving its exit status object to +status+
-    # === Returns
-    # returns   +self+; +stdout+, +stderr+, +status+, and +exitstatus+ will be
-    # populated with results of the command
-    # === Raises
-    # * Errno::EACCES  when you are not privileged to execute the command
-    # * Errno::ENOENT  when the command is not available on the system (or not
-    #   in the current $PATH)
-    # * Chef::Exceptions::CommandTimeout  when the command does not complete
-    #   within +timeout+ seconds (default: 60s)
-    def run_command
-      if command_log_prepend
-        Chef::Log.send(command_log_level, "#{command_log_prepend} sh(#{@command})")
-      else
-        Chef::Log.send(command_log_level, "sh(#{@command})")
-      end
-      super
-    end
-
-    # Checks the +exitstatus+ against the set of +valid_exit_codes+. If
-    # +exitstatus+ is not in the list of +valid_exit_codes+, calls +invalid!+,
-    # which raises an Exception.
-    # === Returns
-    # nil::: always returns nil when it does not raise
-    # === Raises
-    # Chef::Exceptions::ShellCommandFailed::: via +invalid!+
-    def error!
-      unless Array(valid_exit_codes).include?(exitstatus)
-        invalid!("Expected process to exit with #{valid_exit_codes.inspect}, but received '#{exitstatus}'")
-      end
-    end
-
-    # Raises a Chef::Exceptions::ShellCommandFailed exception, appending the
-    # command's stdout, stderr, and exitstatus to the exception message.
-    # === Arguments
-    # +msg+:  A String to use as the basis of the exception message. The
-    # default explanation is very generic, providing a more informative message
-    # is highly encouraged.
-    # === Raises
-    # Chef::Exceptions::ShellCommandFailed  always
-    def invalid!(msg=nil)
-      msg ||= "Command produced unexpected results"
-      raise Chef::Exceptions::ShellCommandFailed, msg + "\n" + format_for_exception
-    end
-
-    def inspect
-      "<#{self.class.name}##{object_id}: command: '#@command' process_status: #{@status.inspect} " +
-      "stdout: '#{stdout.strip}' stderr: '#{stderr.strip}' child_pid: #{@child_pid.inspect} " +
-      "environment: #{@environment.inspect} timeout: #{timeout} user: #@user group: #@group working_dir: #@cwd >"
-    end
-
-    private
-
-    def parse_options(opts)
-      opts.each do |option, setting|
-        case option.to_s
-        when 'cwd'
-          self.cwd = setting
-        when 'user'
-          self.user = setting
-        when 'group'
-          self.group = setting
-        when 'umask'
-          self.umask = setting
-        when 'timeout'
-          self.timeout = setting
-        when 'returns'
-          self.valid_exit_codes = Array(setting)
-        when 'live_stream'
-          self.live_stream = setting
-        when 'command_log_level'
-          self.command_log_level = setting
-        when 'command_log_prepend'
-          self.command_log_prepend = setting
-        when 'environment', 'env'
-          # passing :environment => nil means don't set any new ENV vars
-          @environment = setting.nil? ? {} : @environment.dup.merge!(setting)
-        else
-          raise Chef::Exceptions::InvalidCommandOption, "option '#{option.inspect}' is not a valid option for #{self.class.name}"
-        end
-      end
-    end
-
-
+  class ShellOut < Mixlib::ShellOut
   end
 end