microwave 11.400.3 → 11.400.4

data/lib/chef/api_client/registration.rb

@@ -0,0 +1,126 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 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/config'
+require 'chef/rest'
+require 'chef/exceptions'
+
+class Chef
+  class ApiClient
+
+    # ==Chef::ApiClient::Registration
+    # Manages the process of creating or updating a Chef::ApiClient on the
+    # server and writing the resulting private key to disk. Registration uses
+    # the validator credentials for its API calls. This allows it to bootstrap
+    # a new client/node identity by borrowing the validator client identity
+    # when creating a new client.
+    class Registration
+      attr_reader :private_key
+      attr_reader :destination
+      attr_reader :name
+
+      def initialize(name, destination)
+        @name = name
+        @destination = destination
+        @private_key = nil
+      end
+
+      # Runs the client registration process, including creating the client on
+      # the chef-server and writing its private key to disk.
+      #--
+      # If client creation fails with a 5xx, it is retried up to 5 times. These
+      # retries are on top of the retries with randomized exponential backoff
+      # built in to Chef::REST. The retries here are a workaround for failures
+      # caused by resource contention in Hosted Chef when creating a very large
+      # number of clients simultaneously, (e.g., spinning up 100s of ec2 nodes
+      # at once). Future improvements to the affected component should make
+      # these retries unnecessary.
+      def run
+        assert_destination_writable!
+        retries = Config[:client_registration_retries] || 5
+        begin
+          create_or_update
+        rescue Net::HTTPFatalError => e
+          # HTTPFatalError implies 5xx.
+          raise if retries <= 0
+          retries -= 1
+          Chef::Log.warn("Failed to register new client, #{retries} tries remaining")
+          Chef::Log.warn("Response: HTTP #{e.response.code} - #{e}")
+          retry
+        end
+        write_key
+      end
+
+      def assert_destination_writable!
+        if (File.exists?(destination) && !File.writable?(destination)) or !File.writable?(File.dirname(destination))
+          raise Chef::Exceptions::CannotWritePrivateKey, "I cannot write your private key to #{destination} - check permissions?"
+        end
+      end
+
+      def write_key
+        ::File.open(destination, file_flags, 0600) do |f|
+          f.print(private_key)
+        end
+      rescue IOError => e
+        raise Chef::Exceptions::CannotWritePrivateKey, "Error writing private key to #{destination}: #{e}"
+      end
+
+      def create_or_update
+        create
+      rescue Net::HTTPServerException => e
+        # If create fails because the client exists, attempt to update. This
+        # requires admin privileges.
+        raise unless e.response.code == "409"
+        update
+      end
+
+      def create
+        response = http_api.post("clients", :name => name, :admin => false)
+        @private_key = response["private_key"]
+        response
+      end
+
+      def update
+        response = http_api.put("clients/#{name}", :name => name,
+                                                     :admin => false,
+                                                     :private_key => true)
+        if response.respond_to?(:private_key) # Chef 11
+          @private_key = response.private_key
+        else # Chef 10
+          @private_key = response["private_key"]
+        end
+        response
+      end
+
+      def http_api
+        @http_api_as_validator ||= Chef::REST.new(Chef::Config[:chef_server_url],
+                                                  Chef::Config[:validation_client_name],
+                                                  Chef::Config[:validation_key])
+      end
+
+      def file_flags
+        base_flags = File::CREAT|File::TRUNC|File::RDWR
+        # Windows doesn't have symlinks, so it doesn't have NOFOLLOW
+        base_flags |= File::NOFOLLOW if defined?(File::NOFOLLOW)
+        base_flags
+      end
+    end
+  end
+end
+
+

data/lib/chef/application.rb

@@ -0,0 +1,225 @@
+#
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Author:: Mark Mzyk (mmzyk@opscode.com)
+# Copyright:: Copyright (c) 2008 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 'pp'
+require 'socket'
+require 'chef/config'
+require 'chef/exceptions'
+require 'chef/log'
+require 'chef/platform'
+require 'mixlib/cli'
+require 'tmpdir'
+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
+
+    unless Chef::Platform.windows?
+      trap("QUIT") do
+        Chef::Log.info("SIGQUIT received, call stack:\n  " + caller.join("\n  "))
+      end
+
+      trap("HUP") do
+        Chef::Log.info("SIGHUP received, reconfiguring")
+        reconfigure
+      end
+    end
+
+    # Always switch to a readable directory. Keeps subsequent Dir.chdir() {}
+    # from failing due to permissions when launched as a less privileged user.
+  end
+
+  # Reconfigure the application. You'll want to override and super this method.
+  def reconfigure
+    configure_chef
+    configure_logging
+  end
+
+  # Get this party started
+  def run
+    reconfigure
+    setup_application
+    run_application
+  end
+
+  # Parse the configuration file
+  def configure_chef
+    parse_options
+
+    begin
+      case config[:config_file]
+      when /^(http|https):\/\//
+        Chef::REST.new("", nil, nil).fetch(config[:config_file]) { |f| apply_config(f.path) }
+      else
+        ::File::open(config[:config_file]) { |f| apply_config(f.path) }
+      end
+    rescue Errno::ENOENT => error
+      Chef::Log.warn("*****************************************")
+      Chef::Log.warn("Did not find config file: #{config[:config_file]}, using command line options.")
+      Chef::Log.warn("*****************************************")
+
+      Chef::Config.merge!(config)
+    rescue SocketError => error
+      Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}", 2)
+    rescue Chef::Exceptions::ConfigurationError => error
+      Chef::Application.fatal!("Error processing config file #{Chef::Config[:config_file]} with error #{error.message}", 2)
+    rescue Exception => error
+      Chef::Application.fatal!("Unknown error processing config file #{Chef::Config[:config_file]} with error #{error.message}", 2)
+    end
+
+  end
+
+  # 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.
+  #
+  # === 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
+    Chef::Log.init(Chef::Config[:log_location])
+    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
+  end
+
+  # Called prior to starting the application, by the run method
+  def setup_application
+    raise Chef::Exceptions::Application, "#{self.to_s}: you must override setup_application"
+  end
+
+  # Actually run the application
+  def run_application
+    raise Chef::Exceptions::Application, "#{self.to_s}: you must override run_application"
+  end
+
+  # Initializes Chef::Client instance and runs it
+  def run_chef_client
+    @chef_client = Chef::Client.new(
+      @chef_client_json, 
+      :override_runlist => config[:override_runlist]
+    )
+    @chef_client_json = nil
+
+    @chef_client.run
+    @chef_client = nil
+  end
+
+  private
+
+  def apply_config(config_file_path)
+    Chef::Config.from_file(config_file_path)
+    Chef::Config.merge!(config)
+  end
+
+  class << self
+    def debug_stacktrace(e)
+      message = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+      chef_stacktrace_out = "Generated at #{Time.now.to_s}\n"
+      chef_stacktrace_out += message
+
+      Chef::FileCache.store("chef-stacktrace.out", chef_stacktrace_out)
+      Chef::Log.fatal("Stacktrace dumped to #{Chef::FileCache.load("chef-stacktrace.out", false)}")
+      Chef::Log.debug(message)
+      true
+    end
+
+    # Log a fatal error message to both STDERR and the Logger, exit the application
+    def fatal!(msg, err = -1)
+      Chef::Log.fatal(msg)
+      Process.exit err
+    end
+
+    def exit!(msg, err = -1)
+      Chef::Log.debug(msg)
+      Process.exit err
+    end
+  end
+
+end

data/lib/chef/application/agent.rb

@@ -0,0 +1,18 @@
+#
+# Author:: AJ Christensen (<aj@opscode.comz>)
+# Copyright:: Copyright (c) 2008 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/application'

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-apply [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-apply cookbook)", "(chef-apply 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