chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/application.rb

@@ -16,6 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'pp'
 require 'socket'
 require 'chef/config'
 require 'chef/exceptions'
@@ -28,11 +29,18 @@ require 'rbconfig'
 class Chef::Application
   include Mixlib::CLI
 
+  class Wakeup < Exception
+  end
+
   def initialize
     super
 
     @chef_client = nil
     @chef_client_json = nil
+    trap("TERM") do
+      Chef::Application.fatal!("SIGTERM received, stopping", 1)
+    end
+
     trap("INT") do
       Chef::Application.fatal!("SIGINT received, stopping", 2)
     end
@@ -92,24 +100,73 @@ class Chef::Application
 
   end
 
-  # Initialize and configure the logger. If the configured log location is not
-  # STDOUT, but stdout is a TTY and we're not daemonizing, we set up a secondary
-  # logger with output to stdout. This way, we magically do the right thing when
-  # the user has configured logging to a file but they're running chef in the
-  # shell to debug something.
+  # Initialize and configure the logger.
+  # === Loggers and Formatters
+  # In Chef 10.x and previous, the Logger was the primary/only way that Chef
+  # communicated information to the user. In Chef 10.14, a new system, "output
+  # formatters" was added, and in Chef 11.0+ it is the default when running
+  # chef in a console (detected by `STDOUT.tty?`). Because output formatters
+  # are more complex than the logger system and users have less experience with
+  # them, the config option `force_logger` is provided to restore the Chef 10.x
+  # behavior.
+  #
+  # Conversely, for users who want formatter output even when chef is running
+  # unattended, the `force_formatter` option is provided.
   #
-  # If the user has configured a formatter, then we skip the magical logger to
-  # keep the output pretty.
+  # === Auto Log Level
+  # When `log_level` is set to `:auto` (default), the log level will be `:warn`
+  # when the primary output mode is an output formatter (see
+  # +using_output_formatter?+) and `:info` otherwise.
+  #
+  # === Automatic STDOUT Logging
+  # When `force_logger` is configured (e.g., Chef 10 mode), a second logger
+  # with output on STDOUT is added when running in a console (STDOUT is a tty)
+  # and the configured log_location isn't STDOUT. This accounts for the case
+  # that a user has configured a log_location in client.rb, but is running
+  # chef-client by hand to troubleshoot a problem.
   def configure_logging
-    require 'pp'
     Chef::Log.init(Chef::Config[:log_location])
-    if ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty? && (!Chef::Config[:daemonize]) && (Chef::Config.formatter == "null")
-      stdout_logger = Logger.new(STDOUT)
-      STDOUT.sync = true
-      stdout_logger.formatter = Chef::Log.logger.formatter
-      Chef::Log.loggers <<  stdout_logger
+    if want_additional_logger?
+      configure_stdout_logger
+    end
+    Chef::Log.level = resolve_log_level
+  end
+
+  def configure_stdout_logger
+    stdout_logger = Logger.new(STDOUT)
+    STDOUT.sync = true
+    stdout_logger.formatter = Chef::Log.logger.formatter
+    Chef::Log.loggers <<  stdout_logger
+  end
+
+  # Based on config and whether or not STDOUT is a tty, should we setup a
+  # secondary logger for stdout?
+  def want_additional_logger?
+    ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty? && (!Chef::Config[:daemonize]) && (Chef::Config[:force_logger])
+  end
+
+  # Use of output formatters is assumed if `force_formatter` is set or if
+  # `force_logger` is not set and STDOUT is to a console (tty)
+  def using_output_formatter?
+    Chef::Config[:force_formatter] || (!Chef::Config[:force_logger] && STDOUT.tty?)
+  end
+
+  def auto_log_level?
+    Chef::Config[:log_level] == :auto
+  end
+
+  # if log_level is `:auto`, convert it to :warn (when using output formatter)
+  # or :info (no output formatter). See also +using_output_formatter?+
+  def resolve_log_level
+    if auto_log_level?
+      if using_output_formatter?
+        :warn
+      else
+        :info
+      end
+    else
+      Chef::Config[:log_level]
     end
-    Chef::Log.level = Chef::Config[:log_level]
   end
 
   # Called prior to starting the application, by the run method

data/lib/chef/application/apply.rb

@@ -0,0 +1,160 @@
+#
+# Author:: Bryan W. Berry (<bryan.berry@gmail.com>)
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2012 Bryan W. Berry
+# Copyright:: Copyright (c) 2012 Daniel DeLeo
+# 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'
+require 'chef/application'
+require 'chef/client'
+require 'chef/config'
+require 'chef/log'
+require 'fileutils'
+require 'tempfile'
+require 'chef/providers'
+require 'chef/resources'
+
+class Chef::Application::Apply < Chef::Application
+
+  banner "Usage: chef-recipe [RECIPE_FILE] [-e RECIPE_TEXT] [-s]"
+
+
+  option :execute,
+    :short        => "-e RECIPE_TEXT",
+    :long         => "--execute RECIPE_TEXT",
+    :description  => "Execute resources supplied in a string",
+    :proc         => nil
+
+  option :stdin,
+    :short        => "-s",
+    :long         => "--stdin",
+    :description  => "Execute resources read from STDIN",
+    :boolean      => true
+
+  option :log_level,
+    :short        => "-l LEVEL",
+    :long         => "--log_level LEVEL",
+    :description  => "Set the log level (debug, info, warn, error, fatal)",
+    :proc         => lambda { |l| l.to_sym }
+
+  option :help,
+    :short        => "-h",
+    :long         => "--help",
+    :description  => "Show this message",
+    :on           => :tail,
+    :boolean      => true,
+    :show_options => true,
+    :exit         => 0
+
+
+  option :version,
+    :short        => "-v",
+    :long         => "--version",
+    :description  => "Show chef version",
+    :boolean      => true,
+    :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
+    :exit         => 0
+
+  option :why_run,
+    :short        => '-W',
+    :long         => '--why-run',
+    :description  => 'Enable whyrun mode',
+    :boolean      => true
+
+  def initialize
+    super
+  end
+
+  def reconfigure
+    configure_logging
+  end
+
+  def read_recipe_file(file_name)
+    recipe_path = file_name
+    unless File.exist?(recipe_path)
+      Chef::Application.fatal!("No file exists at #{recipe_path}", 1)
+    end
+    recipe_path = File.expand_path(recipe_path)
+    recipe_fh = open(recipe_path)
+    recipe_text = recipe_fh.read
+    [recipe_text, recipe_fh]
+  end
+
+  def get_recipe_and_run_context
+    Chef::Config[:solo] = true
+    @chef_client = Chef::Client.new
+    @chef_client.run_ohai
+    @chef_client.load_node
+    @chef_client.build_node
+    run_context = if @chef_client.events.nil?
+                    Chef::RunContext.new(@chef_client.node, {})
+                  else
+                    Chef::RunContext.new(@chef_client.node, {}, @chef_client.events)
+                  end
+    recipe = Chef::Recipe.new("(chef-recipe cookbook)", "(chef-recipe recipe)", run_context)
+    [recipe, run_context]
+  end
+
+  # write recipe to temp file, so in case of error,
+  # user gets error w/ context
+  def temp_recipe_file
+    @recipe_fh = Tempfile.open('recipe-temporary-file')
+    @recipe_fh.write(@recipe_text)
+    @recipe_fh.rewind
+    @recipe_filename = @recipe_fh.path
+  end
+
+  def run_chef_recipe
+    if config[:execute]
+      @recipe_text = config[:execute]
+      temp_recipe_file
+    elsif config[:stdin]
+      @recipe_text = STDIN.read
+      temp_recipe_file
+    else
+      @recipe_filename = ARGV[0]
+      @recipe_text,@recipe_fh = read_recipe_file @recipe_filename
+    end
+    recipe,run_context = get_recipe_and_run_context
+    recipe.instance_eval(@recipe_text, @recipe_filename, 1)
+    runner = Chef::Runner.new(run_context)
+    begin
+      runner.converge
+    ensure
+      @recipe_fh.close
+    end
+  end
+
+  def run_application
+    begin
+      parse_options
+      run_chef_recipe
+      Chef::Application.exit! "Exiting", 0
+    rescue SystemExit => e
+      raise
+    rescue Exception => e
+      Chef::Application.debug_stacktrace(e)
+      Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
+    end
+  end
+
+    # Get this party started
+  def run
+    reconfigure
+    run_application
+  end
+
+end

data/lib/chef/application/client.rb

@@ -40,12 +40,25 @@ class Chef::Application::Client < Chef::Application
   option :formatter,
     :short        => "-F FORMATTER",
     :long         => "--format FORMATTER",
-    :description  => "output format to use"
+    :description  => "output format to use",
+    :proc         => lambda { |format| Chef::Config.add_formatter(format) }
+
+  option :force_logger,
+    :long         => "--force-logger",
+    :description  => "Use logger output instead of formatter output",
+    :boolean      => true,
+    :default      => false
+
+  option :force_formatter,
+    :long         => "--force-formatter",
+    :description  => "Use formatter output instead of logger output",
+    :boolean      => true,
+    :default      => false
 
   option :color,
     :long         => '--[no-]color',
     :boolean      => true,
-    :default      => false,
+    :default      => true,
     :description  => "Use colored output, defaults to enabled"
 
   option :log_level,
@@ -81,11 +94,13 @@ class Chef::Application::Client < Chef::Application
     :description => "Group to set privilege to",
     :proc => nil
 
-  option :daemonize,
-    :short => "-d",
-    :long => "--daemonize",
-    :description => "Daemonize the process",
-    :proc => lambda { |p| true }
+  unless Chef::Platform.windows?
+    option :daemonize,
+      :short => "-d",
+      :long => "--daemonize",
+      :description => "Daemonize the process",
+      :proc => lambda { |p| true }
+  end
 
   option :pid_file,
     :short        => "-P PID_FILE",
@@ -186,7 +201,6 @@ class Chef::Application::Client < Chef::Application
 
   def initialize
     super
-    @exit_gracefully = false
   end
 
   # Reconfigure the chef client
@@ -255,15 +269,6 @@ class Chef::Application::Client < Chef::Application
         Chef::Log.info("SIGUSR1 received, waking up")
         SELF_PIPE[1].putc('.') # wakeup master process from select
       end
-
-      # see CHEF-5172
-      if Chef::Config[:daemonize] || Chef::Config[:interval]
-        trap("TERM") do
-          Chef::Log.info("SIGTERM received, exiting gracefully")
-          @exit_gracefully = true
-          SELF_PIPE[1].putc('.')
-        end
-      end
     end
 
     if Chef::Config[:version]
@@ -276,7 +281,6 @@ class Chef::Application::Client < Chef::Application
 
     loop do
       begin
-        Chef::Application.exit!("Exiting", 0) if @exit_gracefully
         if Chef::Config[:splay]
           splay = rand Chef::Config[:splay]
           Chef::Log.debug("Splay sleep #{splay} seconds")
@@ -294,6 +298,9 @@ class Chef::Application::Client < Chef::Application
         else
           Chef::Application.exit! "Exiting", 0
         end
+      rescue Chef::Application::Wakeup => e
+        Chef::Log.debug("Received Wakeup signal.  Starting run.")
+        next
       rescue SystemExit => e
         raise
       rescue Exception => e

data/lib/chef/application/knife.rb

@@ -19,8 +19,6 @@ require 'chef/knife'
 require 'chef/application'
 require 'mixlib/log'
 require 'ohai/config'
-require 'chef/monkey_patches/net_http.rb'
-require 'chef/monkey_patches/uri.rb'
 
 class Chef::Application::Knife < Chef::Application
 

data/lib/chef/application/solo.rb

@@ -37,13 +37,26 @@ class Chef::Application::Solo < Chef::Application
   option :formatter,
     :short        => "-F FORMATTER",
     :long         => "--format FORMATTER",
-    :description  => "output format to use"
+    :description  => "output format to use",
+    :proc         => lambda { |format| Chef::Config.add_formatter(format) }
+
+  option :force_logger,
+    :long         => "--force-logger",
+    :description  => "Use logger output instead of formatter output",
+    :boolean      => true,
+    :default      => false
+
+  option :force_formatter,
+    :long         => "--force-formatter",
+    :description  => "Use formatter output instead of logger output",
+    :boolean      => true,
+    :default      => false
 
   option :color,
     :long         => '--[no-]color',
     :boolean      => true,
-    :default      => false,
-    :description  => "Use colored output, defaults to disabled"
+    :default      => true,
+    :description  => "Use colored output, defaults to enabled"
 
   option :log_level,
     :short        => "-l LEVEL",
@@ -78,11 +91,13 @@ class Chef::Application::Solo < Chef::Application
     :description => "Group to set privilege to",
     :proc => nil
 
-  option :daemonize,
-    :short => "-d",
-    :long => "--daemonize",
-    :description => "Daemonize the process",
-    :proc => lambda { |p| true }
+  unless Chef::Platform.windows?
+    option :daemonize,
+      :short => "-d",
+      :long => "--daemonize",
+      :description => "Daemonize the process",
+      :proc => lambda { |p| true }
+  end
 
   option :interval,
     :short => "-i SECONDS",

data/lib/chef/application/windows_service.rb

@@ -92,6 +92,9 @@ class Chef
 
               Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")
               client_sleep Chef::Config[:interval]
+            rescue Chef::Application::Wakeup => e
+              Chef::Log.debug("Received Wakeup signal.  Starting run.")
+              next
             rescue SystemExit => e
               raise
             rescue Exception => e
@@ -167,7 +170,7 @@ class Chef
       def configure_chef(startup_parameters)
         # Bit of a hack ahead:
         # It is possible to specify a service's binary_path_name with arguments, like "foo.exe -x argX".
-        # It is also possible to specify startup parameters separately, either via the Services manager
+        # It is also possible to specify startup parameters separately, either via the the Services manager
         # or by using the registry (I think).
 
         # In order to accommodate all possible sources of parameterization, we first parse any command line
@@ -215,7 +218,7 @@ class Chef
           sleep chunk_length
         end
       end
-
+      
     end
   end
 end

data/lib/chef/applications.rb

@@ -2,3 +2,4 @@ require 'chef/application/agent'
 require 'chef/application/client'
 require 'chef/application/knife'
 require 'chef/application/solo'
+require 'chef/application/apply'