chef 0.9.18 → 0.10.0.beta.0

data/lib/chef/shef.rb

@@ -15,15 +15,14 @@
 # limitations under the License.
 #
 
-require "singleton"
-require "pp"
-require "etc"
-require "mixlib/cli"
+require 'singleton'
+require 'pp'
+require 'etc'
+require 'mixlib/cli'
 
-require 'chef'
 require 'chef/version'
-require "chef/client"
-require "chef/config"
+require 'chef/client'
+require 'chef/config'
 
 require 'chef/shef/shef_session'
 require 'chef/shef/ext'

data/lib/chef/shef/shef_session.rb

@@ -1,14 +1,16 @@
 #--
 # Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
 # Copyright:: Copyright (c) 2009 Daniel DeLeo
+# Copyright:: Copyright (c) 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.
@@ -22,11 +24,12 @@ require 'chef/config'
 require 'chef/client'
 require 'chef/cookbook/cookbook_collection'
 require 'chef/cookbook_loader'
+require 'chef/run_list/run_list_expansion'
 
 module Shef
   class ShefSession
     include Singleton
-    
+
     def self.session_type(type=nil)
       @session_type = type if type
       @session_type
@@ -37,13 +40,13 @@ module Shef
     def initialize
       @node_built = false
     end
-    
+
     def node_built?
       !!@node_built
     end
-    
+
     def reset!
-      loading do 
+      loading do
         rebuild_node
         @node = client.node
         shorten_node_inspect
@@ -55,12 +58,12 @@ module Shef
         @node_built = true
       end
     end
-    
+
     def node_attributes=(attrs)
       @node_attributes = attrs
       @node.consume_attributes(@node_attributes)
     end
-    
+
     def resource_collection
       run_context.resource_collection
     end
@@ -68,25 +71,25 @@ module Shef
     def run_context
       @run_context ||= rebuild_context
     end
-    
+
     def definitions
       nil
     end
-    
+
     def cookbook_loader
       nil
     end
-    
+
     def save_node
       raise "Not Supported! #{self.class.name} doesn't support #save_node, maybe you need to run shef in client mode?"
     end
-    
+
     def rebuild_context
       raise "Not Implemented! :rebuild_collection should be implemented by subclasses"
     end
-    
+
     private
-    
+
     def loading
       show_loading_progress
       begin
@@ -98,7 +101,7 @@ module Shef
         loading_complete(true)
       end
     end
-    
+
     def show_loading_progress
       print "Loading"
       @loading = true
@@ -109,61 +112,63 @@ module Shef
         end
       end
     end
-    
+
     def loading_complete(success)
       @loading = false
       @dot_printer.join
       msg = success ? "done.\n\n" : "epic fail!\n\n"
       print msg
     end
-    
+
     def shorten_node_inspect
       def @node.inspect
         "<Chef::Node:0x#{self.object_id.to_s(16)} @name=\"#{self.name}\">"
       end
     end
-    
+
     def rebuild_node
       raise "Not Implemented! :rebuild_node should be implemented by subclasses"
     end
- 
+
   end
-  
+
   class StandAloneSession < ShefSession
 
     session_type :standalone
-    
+
     def rebuild_context
       @run_context = Chef::RunContext.new(@node, {}) # no recipes
+      @run_context.load(Chef::RunList::RunListExpansionFromDisk.new("_default", [])) # empty recipe list
     end
-    
+
     private
-    
+
     def rebuild_node
       Chef::Config[:solo] = true
       @client = Chef::Client.new
       @client.run_ohai
       @client.build_node
     end
-    
+
   end
-  
+
   class SoloSession < ShefSession
 
     session_type :solo
-    
+
     def definitions
       @run_context.definitions
     end
-    
+
     def rebuild_context
-      Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest) }
-      @run_context = Chef::RunContext.new(@node, Chef::CookbookCollection.new(Chef::CookbookLoader.new))
+      Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, Chef::Config[:cookbook_path]) }
+      @run_context = Chef::RunContext.new(@node, Chef::CookbookCollection.new(Chef::CookbookLoader.new(Chef::Config[:cookbook_path])))
+      @run_context.load(Chef::RunList::RunListExpansionFromDisk.new("_default", []))
       run_status.run_context = run_context
     end
-    
+
     private
-    
+
     def rebuild_node
       # Tell the client we're chef solo so it won't try to contact the server
       Chef::Config[:solo] = true
@@ -171,13 +176,13 @@ module Shef
       @client.run_ohai
       @client.build_node
     end
-    
+
   end
-  
+
   class ClientSession < SoloSession
 
     session_type :client
-    
+
     def save_node
       @client.save_node
     end
@@ -187,6 +192,7 @@ module Shef
       Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::RemoteFileVendor.new(manifest, Chef::REST.new(Chef::Config[:server_url])) }
       cookbook_hash = @client.sync_cookbooks
       @run_context = Chef::RunContext.new(node, Chef::CookbookCollection.new(cookbook_hash))
+      @run_context.load(Chef::RunList::RunListExpansionFromAPI.new("_default", []))
       @run_status.run_context = run_context
     end
 
@@ -228,7 +234,6 @@ module Shef
       ohai_data = @ohai.data.merge(@node.automatic_attrs)
 
       @node.consume_external_attrs(ohai_data,nil)
-      @node.reset_defaults_and_overrides
 
       @node
     end

data/lib/chef/shell_out.rb

@@ -21,6 +21,7 @@ require 'tmpdir'
 require 'chef/log'
 require 'fcntl'
 require 'chef/exceptions'
+require 'chef/shell_out/unix'
 
 class Chef
 
@@ -42,7 +43,20 @@ class Chef
     DEFAULT_READ_TIMEOUT = 60
     DEFAULT_ENVIRONMENT = {'LC_ALL' => 'C'}
 
-    attr_accessor :user, :group, :cwd, :valid_exit_codes
+    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_reader :command, :umask, :environment
     attr_writer :timeout
     attr_reader :execution_time
@@ -96,6 +110,7 @@ class Chef
     #   cmd.run_command # etc.
     def initialize(*command_args)
       @stdout, @stderr = '', ''
+      @live_stream = nil
       @environment = DEFAULT_ENVIRONMENT
       @cwd = nil
       @valid_exit_codes = [0]
@@ -154,56 +169,9 @@ class Chef
     # * Chef::Exceptions::CommandTimeout  when the command does not complete
     #   within +timeout+ seconds (default: 60s)
     def run_command
-      Chef::Log.debug("sh(#{@command})")
-      @child_pid = fork_subprocess
-
-      configure_parent_process_file_descriptors
-      propagate_pre_exec_failure
-
-      @result = nil
-      @execution_time = 0
-
-      # Ruby 1.8.7 and 1.8.6 from mid 2009 try to allocate objects during GC
-      # when calling IO.select and IO#read. Some OS Vendors are not interested
-      # in updating their ruby packages (Apple, *cough*) and we *have to*
-      # make it work. So I give you this epic hack:
-      GC.disable
-      until @status
-        ready = IO.select(open_pipes, nil, nil, READ_WAIT_TIME)
-        unless ready
-          @execution_time += READ_WAIT_TIME
-          if @execution_time >= timeout && !@result
-            raise Chef::Exceptions::CommandTimeout, "command timed out:\n#{format_for_exception}"
-          end
-        end
-
-        if ready && ready.first.include?(child_stdout)
-          read_stdout_to_buffer
-        end
-        if ready && ready.first.include?(child_stderr)
-          read_stderr_to_buffer
-        end
-
-        unless @status
-          # make one more pass to get the last of the output after the
-          # child process dies
-          if results = Process.waitpid2(@child_pid, Process::WNOHANG)
-            @status = results.last
-            redo
-          end
-        end
-      end
-      self
-    rescue Exception
-      # do our best to kill zombies
-      Process.waitpid2(@child_pid, Process::WNOHANG) rescue nil
-      raise
-    ensure
-      # no matter what happens, turn the GC back on, and hope whatever busted
-      # version of ruby we're on doesn't allocate some objects during the next
-      # GC run.
-      GC.enable
-      close_all_pipes
+      # Implemented by unix/windows backend module, we just want to define it
+      # here for documentation purposes
+      super
     end
 
     # Checks the +exitstatus+ against the set of +valid_exit_codes+. If
@@ -255,164 +223,17 @@ class Chef
           self.timeout = setting
         when 'returns'
           self.valid_exit_codes = Array(setting)
+        when 'live_stream'
+          self.live_stream = setting
         when 'environment', 'env'
           # passing :environment => nil means don't set any new ENV vars
-          setting.nil? ? @environment = {} : @environment.merge!(setting)
+          @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
 
-    def set_user
-      if user
-        Process.euid = uid
-        Process.uid = uid
-      end
-    end
-
-    def set_group
-      if group
-        Process.egid = gid
-        Process.gid = gid
-      end
-    end
-
-    def set_environment
-      environment.each do |env_var,value|
-        ENV[env_var] = value
-      end
-    end
-
-    def set_umask
-      File.umask(umask) if umask
-    end
-
-    def set_cwd
-      Dir.chdir(cwd) if cwd
-    end
-
-    def initialize_ipc
-      @stdout_pipe, @stderr_pipe, @process_status_pipe = IO.pipe, IO.pipe, IO.pipe
-      @process_status_pipe.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-    end
-
-    def child_stdout
-      @stdout_pipe[0]
-    end
-
-    def child_stderr
-      @stderr_pipe[0]
-    end
-
-    def child_process_status
-      @process_status_pipe[0]
-    end
-
-    def close_all_pipes
-      child_stdout.close  unless child_stdout.closed?
-      child_stderr.close  unless child_stderr.closed?
-      child_process_status.close unless child_process_status.closed?
-    end
-
-    # replace stdout, and stderr with pipes to the parent, and close the
-    # reader side of the error marshaling side channel. Close STDIN so when we
-    # exec, the new program will know it's never getting input ever.
-    def configure_subprocess_file_descriptors
-      process_status_pipe.first.close
-
-      # HACK: for some reason, just STDIN.close isn't good enough when running
-      # under ruby 1.9.2, so make it good enough:
-      stdin_reader, stdin_writer = IO.pipe
-      stdin_writer.close
-      STDIN.reopen stdin_reader
-      stdin_reader.close
-
-      stdout_pipe.first.close
-      STDOUT.reopen stdout_pipe.last
-      stdout_pipe.last.close
-
-      stderr_pipe.first.close
-      STDERR.reopen stderr_pipe.last
-      stderr_pipe.last.close
-
-      STDOUT.sync = STDERR.sync = true
-    end
-
-    def configure_parent_process_file_descriptors
-      # Close the sides of the pipes we don't care about
-      stdout_pipe.last.close
-      stderr_pipe.last.close
-      process_status_pipe.last.close
-      # Get output as it happens rather than buffered
-      child_stdout.sync = true
-      child_stderr.sync = true
-
-      true
-    end
-
-    # Some patch levels of ruby in wide use (in particular the ruby 1.8.6 on OSX)
-    # segfault when you IO.select a pipe that's reached eof. Weak sauce.
-    def open_pipes
-      @open_pipes ||= [child_stdout, child_stderr]
-    end
-
-    def read_stdout_to_buffer
-      while chunk = child_stdout.read_nonblock(READ_SIZE)
-        @stdout << chunk
-      end
-    rescue Errno::EAGAIN
-    rescue EOFError
-      open_pipes.delete_at(0)
-    end
-
-    def read_stderr_to_buffer
-      while chunk = child_stderr.read_nonblock(READ_SIZE)
-        @stderr << chunk
-      end
-    rescue Errno::EAGAIN
-    rescue EOFError
-      open_pipes.delete_at(1)
-    end
-
-    def fork_subprocess
-      initialize_ipc
-
-      fork do
-        configure_subprocess_file_descriptors
-
-        set_user
-        set_group
-        set_environment
-        set_umask
-        set_cwd
-
-        begin
-          command.kind_of?(Array) ? exec(*command) : exec(command)
-
-          raise 'forty-two' # Should never get here
-        rescue Exception => e
-          Marshal.dump(e, process_status_pipe.last)
-          process_status_pipe.last.flush
-        end
-        process_status_pipe.last.close unless (process_status_pipe.last.closed?)
-        exit!
-      end
-    end
-
-    # Attempt to get a Marshaled error from the side-channel.
-    # If it's there, un-marshal it and raise. If it's not there,
-    # assume everything went well.
-    def propagate_pre_exec_failure
-      begin
-        e = Marshal.load child_process_status
-        raise(Exception === e ? e : "unknown failure: #{e.inspect}")
-      rescue EOFError # If we get an EOF error, then the exec was successful
-        true
-      ensure
-        child_process_status.close
-      end
-    end
 
   end
 end