chef 15.1.36-universal-mingw32 → 15.2.20-universal-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 605f1233768123eef3deeb235bdc0071e01b236c3969af123d2b7477844a9c8c
-  data.tar.gz: b5da43356cf340a071f92e398d28673758529247e314c82c9b23f06776d48298
+  metadata.gz: 594e166bed32da754bf206f64e2109271ddf1469412338557db108e06261e1de
+  data.tar.gz: d0f5d5ba5ffe1d1956b9e5ce0fecb7e0b7e97dd27a7932a1f9e496420b31293a
 SHA512:
-  metadata.gz: 024ba97d25a9e5edf0b36e786f22ee5f3bcbf6c065b2bdbc298689929108c3c2c7f337a5b315dae3901e54d167cd9955fc6fcda188aae070b96645c140a3cdcd
-  data.tar.gz: acbf157a9cc3f70fad66105fd68ae0ac92c3d1da6747f2935e8214143ed99520c5ceb7e96aef44a54d66d58f991fcd206aa4364e01e2df0628414aa3d627d89c
+  metadata.gz: 22da301445b2bdf05d08430e5c76a09f87f1e41a2107d101adbd095bd3037286ebf8626aa83e2200ac658ec8d31b94ab113cf1a77dbb9d57d80d6b9f176d52f5
+  data.tar.gz: 2db2c1bab933e7a5e53fd91ef2a86e53952b6e9669a9f92395c88c5106989dc2e7a6c96bf8c62619228599e4bdeb2145c1042311e54308cfcc21bef7e2d1883e

data/ext/win32-eventlog/Rakefile

@@ -23,7 +23,7 @@ CC = "gcc".freeze
 ensure_present [MC, RC, CC]
 
 task build: [EVT_RESOURCE_OBJECT, EVT_SHARED_OBJECT]
-task default: [:build, :register]
+task default: %i{build register}
 
 file EVT_RC_FILE => EVT_MC_FILE do
   sh "#{MC} #{EVT_MC_FILE}"

data/lib/chef.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,7 +18,6 @@
 
 require_relative "chef/version"
 
-require_relative "chef/nil_argument"
 require_relative "chef/mash"
 require_relative "chef/exceptions"
 require_relative "chef/log"

data/lib/chef/action_collection.rb

@@ -145,6 +145,7 @@ class Chef
     #
     def converge_failed(exception)
       return if consumers.empty?
+
       detect_unprocessed_resources
     end
 
@@ -156,6 +157,7 @@ class Chef
     #
     def resource_action_start(new_resource, action, notification_type = nil, notifier = nil)
       return if consumers.empty?
+
       pending_updates << ActionRecord.new(new_resource, action, pending_updates.length)
     end
 
@@ -166,6 +168,7 @@ class Chef
     #
     def resource_current_state_loaded(new_resource, action, current_resource)
       return if consumers.empty?
+
       current_record.current_resource = current_resource
     end
 
@@ -175,6 +178,7 @@ class Chef
     #
     def resource_up_to_date(new_resource, action)
       return if consumers.empty?
+
       current_record.status = :up_to_date
     end
 
@@ -184,6 +188,7 @@ class Chef
     #
     def resource_skipped(resource, action, conditional)
       return if consumers.empty?
+
       current_record.status = :skipped
       current_record.conditional = conditional
     end
@@ -194,6 +199,7 @@ class Chef
     #
     def resource_updated(new_resource, action)
       return if consumers.empty?
+
       current_record.status = :updated
     end
 
@@ -203,6 +209,7 @@ class Chef
     #
     def resource_failed(new_resource, action, exception)
       return if consumers.empty?
+
       current_record.status = :failed
       current_record.exception = exception
     end
@@ -213,6 +220,7 @@ class Chef
     #
     def resource_completed(new_resource)
       return if consumers.empty?
+
       current_record.elapsed_time = new_resource.elapsed_time
 
       # Verify if the resource has sensitive data and create a new blank resource with only

data/lib/chef/api_client.rb

@@ -157,7 +157,7 @@ class Chef
 
     def self.list(inflate = false)
       if inflate
-        response = Hash.new
+        response = {}
         Chef::Search::Query.new.search(:client) do |n|
           n = json_create(n) if n.instance_of?(Hash)
           response[n.name] = n
@@ -171,7 +171,7 @@ class Chef
     # Load a client by name via the API
     def self.load(name)
       response = http_api.get("clients/#{name}")
-      if response.kind_of?(Chef::ApiClient)
+      if response.is_a?(Chef::ApiClient)
         response
       else
         from_hash(response)

data/lib/chef/api_client/registration.rb

@@ -60,6 +60,7 @@ class Chef
         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}")
@@ -71,7 +72,7 @@ class Chef
 
       def assert_destination_writable!
         abs_path = File.expand_path(destination)
-        if !File.exists?(File.dirname(abs_path))
+        unless File.exists?(File.dirname(abs_path))
           begin
             FileUtils.mkdir_p(File.dirname(abs_path))
           rescue Errno::EACCES
@@ -97,6 +98,7 @@ class Chef
         # If create fails because the client exists, attempt to update. This
         # requires admin privileges.
         raise unless e.response.code == "409"
+
         update
       end
 
@@ -156,12 +158,11 @@ class Chef
 
       def http_api
         @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url],
-                                          {
-                                            api_version: "0",
-                                            client_name: Chef::Config[:validation_client_name],
-                                            signing_key_filename: Chef::Config[:validation_key],
-                                          }
-                                         )
+          {
+            api_version: "0",
+            client_name: Chef::Config[:validation_client_name],
+            signing_key_filename: Chef::Config[:validation_key],
+          })
       end
 
       # Whether or not to generate keys locally and post the public key to the

data/lib/chef/api_client_v1.rb

@@ -190,7 +190,7 @@ class Chef
 
     def self.list(inflate = false)
       if inflate
-        response = Hash.new
+        response = {}
         Chef::Search::Query.new.search(:client) do |n|
           n = from_hash(n) if n.instance_of?(Hash)
           response[n.name] = n
@@ -270,6 +270,7 @@ class Chef
         # rescue API V0 if 406 and the server supports V0
         supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
         raise e unless supported_versions && supported_versions.include?(0)
+
         new_client = chef_rest_v0.put("clients/#{name}", payload)
       end
 

data/lib/chef/application.rb

@@ -353,6 +353,7 @@ class Chef
     def handle_child_exit(pid_and_status)
       status = pid_and_status[1]
       return true if status.success?
+
       message = if status.signaled?
                   "Chef run process terminated by signal #{status.termsig} (#{Signal.list.invert[status.termsig]})"
                 else

data/lib/chef/application/apply.rb

@@ -184,7 +184,7 @@ class Chef::Application::Apply < Chef::Application
       @recipe_text = STDIN.read
       temp_recipe_file
     else
-      if !ARGV[0]
+      unless ARGV[0]
         puts opt_parser
         Chef::Application.exit! "No recipe file provided", Chef::Exceptions::RecipeNotFound.new
       end

data/lib/chef/application/base.rb

@@ -0,0 +1,440 @@
+#
+# Copyright:: Copyright 2008-2019, Chef Software 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_relative "../application"
+require_relative "../client"
+require_relative "../log"
+require_relative "../config"
+require_relative "../mixin/shell_out"
+require_relative "../config_fetcher"
+require_relative "../dist"
+require_relative "../daemon"
+require "chef-config/mixin/dot_d"
+require "license_acceptance/cli_flags/mixlib_cli"
+require "mixlib/archive" unless defined?(Mixlib::Archive)
+
+# This is a temporary class being used as a part of an effort to reduce duplication
+# between Chef::Application::Client and Chef::Application::Solo.
+#
+# If you are looking to make edits to the Client/Solo behavior please make changes here.
+#
+# If you are looking to reference or subclass this class, use Chef::Application::Client
+# instead.  This base class will be removed once the work is complete and external code
+# will break.
+#
+# @deprecated use Chef::Application::Client instead, this will be removed in Chef-16
+#
+class Chef::Application::Base < Chef::Application
+  include Chef::Mixin::ShellOut
+  include ChefConfig::Mixin::DotD
+  include LicenseAcceptance::CLIFlags::MixlibCLI
+
+  # Mimic self_pipe sleep from Unicorn to capture signals safely
+  SELF_PIPE = [] # rubocop:disable Style/MutableConstant
+
+  option :config_option,
+    long: "--config-option OPTION=VALUE",
+    description: "Override a single configuration option.",
+    proc: lambda { |option, existing|
+      (existing ||= []) << option
+      existing
+    }
+
+  option :once,
+    long: "--once",
+    description: "Cancel any interval or splay options, run #{Chef::Dist::PRODUCT} once and exit.",
+    boolean: true
+
+  option :formatter,
+    short: "-F FORMATTER",
+    long: "--format FORMATTER",
+    description: "The 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 :profile_ruby,
+    long: "--[no-]profile-ruby",
+    description: "Dump complete Ruby call graph stack of entire #{Chef::Dist::PRODUCT} run (expert only).",
+    boolean: true,
+    default: false
+
+  option :color,
+    long: "--[no-]color",
+    boolean: true,
+    default: true,
+    description: "Use colored output, defaults to enabled."
+
+  option :log_level,
+    short: "-l LEVEL",
+    long: "--log_level LEVEL",
+    description: "Set the log level (auto, trace, debug, info, warn, error, fatal).",
+    proc: lambda { |l| l.to_sym }
+
+  option :log_location,
+    short: "-L LOGLOCATION",
+    long: "--logfile LOGLOCATION",
+    description: "Set the log file location, defaults to STDOUT - recommended for daemonizing.",
+    proc: nil
+
+  option :help,
+    short: "-h",
+    long: "--help",
+    description: "Show this help message.",
+    on: :tail,
+    boolean: true,
+    show_options: true,
+    exit: 0
+
+  option :user,
+    short: "-u USER",
+    long: "--user USER",
+    description: "User to set privilege to.",
+    proc: nil
+
+  option :group,
+    short: "-g GROUP",
+    long: "--group GROUP",
+    description: "Group to set privilege to.",
+    proc: nil
+
+  option :lockfile,
+    long: "--lockfile LOCKFILE",
+    description: "Set the lockfile location. Prevents multiple client processes from converging at the same time.",
+    proc: nil
+
+  option :interval,
+    short: "-i SECONDS",
+    long: "--interval SECONDS",
+    description: "Run #{Chef::Dist::PRODUCT} periodically, in seconds.",
+    proc: lambda { |s| s.to_i }
+
+  option :json_attribs,
+    short: "-j JSON_ATTRIBS",
+    long: "--json-attributes JSON_ATTRIBS",
+    description: "Load attributes from a JSON file or URL.",
+    proc: nil
+
+  option :node_name,
+    short: "-N NODE_NAME",
+    long: "--node-name NODE_NAME",
+    description: "The node name for this client.",
+    proc: nil
+
+  option :splay,
+    short: "-s SECONDS",
+    long: "--splay SECONDS",
+    description: "The splay time for running at intervals, in seconds.",
+    proc: lambda { |s| s.to_i }
+
+  option :environment,
+    short: "-E ENVIRONMENT",
+    long: "--environment ENVIRONMENT",
+    description: "Set the #{Chef::Dist::PRODUCT} environment on the node."
+
+  option :client_fork,
+    short: "-f",
+    long: "--[no-]fork",
+    description: "Fork #{Chef::Dist::PRODUCT} process."
+
+  option :why_run,
+    short: "-W",
+    long: "--why-run",
+    description: "Enable whyrun mode.",
+    boolean: true
+
+  option :override_runlist,
+    short: "-o RunlistItem,RunlistItem...",
+    long: "--override-runlist RunlistItem,RunlistItem...",
+    description: "Replace current run list with specified items for a single run.",
+    proc: lambda { |items|
+      items = items.split(",")
+      items.compact.map do |item|
+        Chef::RunList::RunListItem.new(item)
+      end
+    }
+
+  option :run_lock_timeout,
+    long: "--run-lock-timeout SECONDS",
+    description: "Set maximum duration to wait for another client run to finish, default is indefinitely.",
+    proc: lambda { |s| s.to_i }
+
+  option :version,
+    short: "-v",
+    long: "--version",
+    description: "Show #{Chef::Dist::PRODUCT} version.",
+    boolean: true,
+    proc: lambda { |v| puts "#{Chef::Dist::PRODUCT}: #{::Chef::VERSION}" },
+    exit: 0
+
+  option :minimal_ohai,
+    long: "--minimal-ohai",
+    description: "Only run the bare minimum Ohai plugins #{Chef::Dist::PRODUCT} needs to function.",
+    boolean: true
+
+  option :delete_entire_chef_repo,
+    long: "--delete-entire-chef-repo",
+    description: "DANGEROUS: does what it says, only useful with --recipe-url.",
+    boolean: true
+
+  option :ez,
+    long: "--ez",
+    description: "A memorial for Ezra Zygmuntowicz.",
+    boolean: true
+
+  option :target,
+    short: "-t TARGET",
+    long: "--target TARGET",
+    description: "Target #{Chef::Dist::PRODUCT} against a remote system or device",
+    proc: lambda { |target|
+      Chef::Log.warn "-- EXPERIMENTAL -- Target mode activated, resources and dsl may change without warning -- EXPERIMENTAL --"
+      target
+    }
+
+  option :disable_config,
+    long: "--disable-config",
+    description: "Refuse to load a config file and use defaults. This is for development and not a stable API.",
+    boolean: true
+
+  if Chef::Platform.windows?
+    option :fatal_windows_admin_check,
+      short: "-A",
+      long: "--fatal-windows-admin-check",
+      description: "Fail the run when #{Chef::Dist::CLIENT} doesn't have administrator privileges on Windows.",
+      boolean: true
+  end
+
+  option :fips,
+    long: "--[no-]fips",
+    description: "Enable FIPS mode.",
+    boolean: true
+
+  option :solo_legacy_mode,
+    long: "--legacy-mode",
+    description: "Run in legacy mode.",
+    boolean: true
+
+  option :chef_server_url,
+    short: "-S CHEFSERVERURL",
+    long: "--server CHEFSERVERURL",
+    description: "The #{Chef::Dist::SERVER_PRODUCT} URL.",
+    proc: nil
+
+  option :validation_key,
+    short: "-K KEY_FILE",
+    long: "--validation_key KEY_FILE",
+    description: "Set the validation key file location, used for registering new clients.",
+    proc: nil
+
+  option :client_key,
+    short: "-k KEY_FILE",
+    long: "--client_key KEY_FILE",
+    description: "Set the client key file location.",
+    proc: nil
+
+  option :enable_reporting,
+    short: "-R",
+    long: "--enable-reporting",
+    description: "(#{Chef::Dist::CLIENT} only) reporting data collection for runs.",
+    boolean: true
+
+  option :local_mode,
+    short: "-z",
+    long: "--local-mode",
+    description: "Point at local repository.",
+    boolean: true
+
+  option :chef_zero_host,
+    long: "--chef-zero-host HOST",
+    description: "Host to start #{Chef::Dist::ZERO} on."
+
+  option :chef_zero_port,
+    long: "--chef-zero-port PORT",
+    description: "Port (or port range) to start #{Chef::Dist::ZERO} on. Port ranges like 1000,1010 or 8889-9999 will try all given ports until one works."
+
+  option :listen,
+    long: "--[no-]listen",
+    description: "Whether a local mode (-z) server binds to a port.",
+    boolean: false
+
+  option :skip_cookbook_sync,
+    long: "--[no-]skip-cookbook-sync",
+    description: "(#{Chef::Dist::CLIENT} only) Use cached cookbooks without overwriting local differences from the #{Chef::Dist::SERVER_PRODUCT}.",
+    boolean: false
+
+  option :named_run_list,
+    short: "-n NAMED_RUN_LIST",
+    long: "--named-run-list NAMED_RUN_LIST",
+    description: "Use a policyfile's named run list instead of the default run list."
+
+  IMMEDIATE_RUN_SIGNAL = "1".freeze
+  RECONFIGURE_SIGNAL = "H".freeze
+
+  attr_reader :chef_client_json
+
+  def setup_application
+    Chef::Daemon.change_privilege
+  end
+
+  def setup_signal_handlers
+    super
+
+    unless Chef::Platform.windows?
+      SELF_PIPE.replace IO.pipe
+
+      trap("USR1") do
+        Chef::Log.info("SIGUSR1 received, will run now or after the current run")
+        SELF_PIPE[1].putc(IMMEDIATE_RUN_SIGNAL) # wakeup master process from select
+      end
+
+      # Override the trap setup in the parent so we can avoid running reconfigure during a run
+      trap("HUP") do
+        Chef::Log.info("SIGHUP received, will reconfigure now or after the current run")
+        SELF_PIPE[1].putc(RECONFIGURE_SIGNAL) # wakeup master process from select
+      end
+    end
+  end
+
+  # Run the chef client, optionally daemonizing or looping at intervals.
+  def run_application
+    if Chef::Config[:version]
+      puts "#{Chef::Dist::PRODUCT} version: #{::Chef::VERSION}"
+    end
+
+    if !Chef::Config[:client_fork] || Chef::Config[:once]
+      begin
+        # run immediately without interval sleep, or splay
+        run_chef_client(Chef::Config[:specific_recipes])
+      rescue SystemExit
+        raise
+      rescue Exception => e
+        Chef::Application.fatal!("#{e.class}: #{e.message}", e)
+      end
+    else
+      interval_run_chef_client
+    end
+  end
+
+  private
+
+  def unforked_interval_error_message
+    "Unforked #{Chef::Dist::PRODUCT} interval runs are disabled by default." +
+      "\nConfiguration settings:" +
+      ("\n  interval  = #{Chef::Config[:interval]} seconds" if Chef::Config[:interval]).to_s +
+      "\nEnable #{Chef::Dist::PRODUCT} interval runs by setting `:client_fork = true` in your config file or adding `--fork` to your command line options."
+  end
+
+  def fetch_recipe_tarball(url, path)
+    Chef::Log.trace("Download recipes tarball from #{url} to #{path}")
+    if File.exist?(url)
+      FileUtils.cp(url, path)
+    elsif url =~ URI.regexp
+      File.open(path, "wb") do |f|
+        open(url) do |r|
+          f.write(r.read)
+        end
+      end
+    else
+      Chef::Application.fatal! "You specified --recipe-url but the value is neither a valid URL nor a path to a file that exists on disk." +
+        "Please confirm the location of the tarball and try again."
+    end
+  end
+
+  def interval_run_chef_client
+    if Chef::Config[:daemonize]
+      Chef::Daemon.daemonize(Chef::Dist::PRODUCT)
+
+      # Start first daemonized run after configured number of seconds
+      if Chef::Config[:daemonize].is_a?(Integer)
+        sleep_then_run_chef_client(Chef::Config[:daemonize])
+      end
+    end
+
+    loop do
+      sleep_then_run_chef_client(time_to_sleep)
+      Chef::Application.exit!("Exiting", 0) unless Chef::Config[:interval]
+    end
+  end
+
+  def sleep_then_run_chef_client(sleep_sec)
+    Chef::Log.trace("Sleeping for #{sleep_sec} seconds")
+
+    # interval_sleep will return early if we received a signal (unless on windows)
+    interval_sleep(sleep_sec)
+
+    run_chef_client(Chef::Config[:specific_recipes])
+
+    reconfigure
+  rescue SystemExit => e
+    raise
+  rescue Exception => e
+    if Chef::Config[:interval]
+      Chef::Log.error("#{e.class}: #{e}")
+      Chef::Log.trace("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
+      retry
+    end
+
+    Chef::Application.fatal!("#{e.class}: #{e.message}", e)
+  end
+
+  def time_to_sleep
+    duration = 0
+    duration += rand(Chef::Config[:splay]) if Chef::Config[:splay]
+    duration += Chef::Config[:interval] if Chef::Config[:interval]
+    duration
+  end
+
+  # sleep and handle queued signals
+  def interval_sleep(sec)
+    unless SELF_PIPE.empty?
+      # mimic sleep with a timeout on IO.select, listening for signals setup in #setup_signal_handlers
+      return unless IO.select([ SELF_PIPE[0] ], nil, nil, sec)
+
+      signal = SELF_PIPE[0].getc.chr
+
+      return if signal == IMMEDIATE_RUN_SIGNAL # be explicit about this behavior
+
+      # we need to sleep again after reconfigure to avoid stampeding when logrotate runs out of cron
+      if signal == RECONFIGURE_SIGNAL
+        reconfigure
+        interval_sleep(sec)
+      end
+    else
+      sleep(sec)
+    end
+  end
+
+  def for_ezra
+    puts <<~EOH
+      For Ezra Zygmuntowicz:
+        The man who brought you Chef Solo
+        Early contributor to Chef
+        Kind hearted open source advocate
+        Rest in peace, Ezra.
+    EOH
+  end
+
+end