chef 12.18.31 → 13.0.118

data/lib/chef/provider/git.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -28,17 +28,13 @@ class Chef
       extend Forwardable
       provides :git
 
-      def_delegator :@new_resource, :destination, :cwd
-
-      def whyrun_supported?
-        true
-      end
+      def_delegator :new_resource, :destination, :cwd
 
       def load_current_resource
         @resolved_reference = nil
-        @current_resource = Chef::Resource::Git.new(@new_resource.name)
+        @current_resource = Chef::Resource::Git.new(new_resource.name)
         if current_revision = find_current_revision
-          @current_resource.revision current_revision
+          current_resource.revision current_revision
         end
       end
 
@@ -49,16 +45,16 @@ class Chef
           a.assertion { ::File.directory?(dirname) }
           a.whyrun("Directory #{dirname} does not exist, this run will fail unless it has been previously created. Assuming it would have been created.")
           a.failure_message(Chef::Exceptions::MissingParentDirectory,
-            "Cannot clone #{@new_resource} to #{cwd}, the enclosing directory #{dirname} does not exist")
+            "Cannot clone #{new_resource} to #{cwd}, the enclosing directory #{dirname} does not exist")
         end
 
         requirements.assert(:all_actions) do |a|
-          a.assertion { !(@new_resource.revision =~ /^origin\//) }
+          a.assertion { !(new_resource.revision =~ /^origin\//) }
           a.failure_message Chef::Exceptions::InvalidRemoteGitReference,
              "Deploying remote branches is not supported. " +
             "Specify the remote branch as a local branch for " +
             "the git repository you're deploying from " +
-            "(ie: '#{@new_resource.revision.gsub('origin/', '')}' rather than '#{@new_resource.revision}')."
+            "(ie: '#{new_resource.revision.gsub('origin/', '')}' rather than '#{new_resource.revision}')."
         end
 
         requirements.assert(:all_actions) do |a|
@@ -67,22 +63,22 @@ class Chef
           # if we can't resolve it up front.
           a.assertion { !target_revision.nil? }
           a.failure_message Chef::Exceptions::UnresolvableGitReference,
-            "Unable to parse SHA reference for '#{@new_resource.revision}' in repository '#{@new_resource.repository}'. " +
+            "Unable to parse SHA reference for '#{new_resource.revision}' in repository '#{new_resource.repository}'. " +
             "Verify your (case-sensitive) repository URL and revision.\n" +
-            "`git ls-remote '#{@new_resource.repository}' '#{rev_search_pattern}'` output: #{@resolved_reference}"
+            "`git ls-remote '#{new_resource.repository}' '#{rev_search_pattern}'` output: #{@resolved_reference}"
         end
       end
 
       def action_checkout
         if target_dir_non_existent_or_empty?
           clone
-          if @new_resource.enable_checkout
+          if new_resource.enable_checkout
             checkout
           end
           enable_submodules
           add_remotes
         else
-          Chef::Log.debug "#{@new_resource} checkout destination #{cwd} already exists or is a non-empty directory"
+          Chef::Log.debug "#{new_resource} checkout destination #{cwd} already exists or is a non-empty directory"
         end
       end
 
@@ -95,11 +91,11 @@ class Chef
 
       def action_sync
         if existing_git_clone?
-          Chef::Log.debug "#{@new_resource} current revision: #{@current_resource.revision} target revision: #{target_revision}"
+          Chef::Log.debug "#{new_resource} current revision: #{current_resource.revision} target revision: #{target_revision}"
           unless current_revision_matches_target_revision?
             fetch_updates
             enable_submodules
-            Chef::Log.info "#{@new_resource} updated to revision #{target_revision}"
+            Chef::Log.info "#{new_resource} updated to revision #{target_revision}"
           end
           add_remotes
         else
@@ -120,7 +116,7 @@ class Chef
       end
 
       def find_current_revision
-        Chef::Log.debug("#{@new_resource} finding current git revision")
+        Chef::Log.debug("#{new_resource} finding current git revision")
         if ::File.exist?(::File.join(cwd, ".git"))
           # 128 is returned when we're not in a git repo. this is fine
           result = git("rev-parse", "HEAD", cwd: cwd, returns: [0, 128]).stdout.strip
@@ -129,10 +125,10 @@ class Chef
       end
 
       def add_remotes
-        if @new_resource.additional_remotes.length > 0
-          @new_resource.additional_remotes.each_pair do |remote_name, remote_url|
+        if new_resource.additional_remotes.length > 0
+          new_resource.additional_remotes.each_pair do |remote_name, remote_url|
             converge_by("add remote #{remote_name} from #{remote_url}") do
-              Chef::Log.info "#{@new_resource} adding git remote #{remote_name} = #{remote_url}"
+              Chef::Log.info "#{new_resource} adding git remote #{remote_name} = #{remote_url}"
               setup_remote_tracking_branches(remote_name, remote_url)
             end
           end
@@ -140,17 +136,17 @@ class Chef
       end
 
       def clone
-        converge_by("clone from #{@new_resource.repository} into #{cwd}") do
-          remote = @new_resource.remote
+        converge_by("clone from #{new_resource.repository} into #{cwd}") do
+          remote = new_resource.remote
 
           clone_cmd = ["clone"]
           clone_cmd << "-o #{remote}" unless remote == "origin"
-          clone_cmd << "--depth #{@new_resource.depth}" if @new_resource.depth
-          clone_cmd << "--no-single-branch" if @new_resource.depth && git_minor_version >= Gem::Version.new("1.7.10")
-          clone_cmd << "\"#{@new_resource.repository}\""
+          clone_cmd << "--depth #{new_resource.depth}" if new_resource.depth
+          clone_cmd << "--no-single-branch" if new_resource.depth && git_minor_version >= Gem::Version.new("1.7.10")
+          clone_cmd << "\"#{new_resource.repository}\""
           clone_cmd << "\"#{cwd}\""
 
-          Chef::Log.info "#{@new_resource} cloning repo #{@new_resource.repository} to #{cwd}"
+          Chef::Log.info "#{new_resource} cloning repo #{new_resource.repository} to #{cwd}"
           git clone_cmd
         end
       end
@@ -158,20 +154,20 @@ class Chef
       def checkout
         sha_ref = target_revision
 
-        converge_by("checkout ref #{sha_ref} branch #{@new_resource.revision}") do
+        converge_by("checkout ref #{sha_ref} branch #{new_resource.revision}") do
           # checkout into a local branch rather than a detached HEAD
-          git("branch", "-f", @new_resource.checkout_branch, sha_ref, cwd: cwd)
-          git("checkout", @new_resource.checkout_branch, cwd: cwd)
-          Chef::Log.info "#{@new_resource} checked out branch: #{@new_resource.revision} onto: #{@new_resource.checkout_branch} reference: #{sha_ref}"
+          git("branch", "-f", new_resource.checkout_branch, sha_ref, cwd: cwd)
+          git("checkout", new_resource.checkout_branch, cwd: cwd)
+          Chef::Log.info "#{new_resource} checked out branch: #{new_resource.revision} onto: #{new_resource.checkout_branch} reference: #{sha_ref}"
         end
       end
 
       def enable_submodules
-        if @new_resource.enable_submodules
-          converge_by("enable git submodules for #{@new_resource}") do
-            Chef::Log.info "#{@new_resource} synchronizing git submodules"
+        if new_resource.enable_submodules
+          converge_by("enable git submodules for #{new_resource}") do
+            Chef::Log.info "#{new_resource} synchronizing git submodules"
             git("submodule", "sync", cwd: cwd)
-            Chef::Log.info "#{@new_resource} enabling git submodules"
+            Chef::Log.info "#{new_resource} enabling git submodules"
             # the --recursive flag means we require git 1.6.5+ now, see CHEF-1827
             git("submodule", "update", "--init", "--recursive", cwd: cwd)
           end
@@ -179,19 +175,19 @@ class Chef
       end
 
       def fetch_updates
-        setup_remote_tracking_branches(@new_resource.remote, @new_resource.repository)
-        converge_by("fetch updates for #{@new_resource.remote}") do
+        setup_remote_tracking_branches(new_resource.remote, new_resource.repository)
+        converge_by("fetch updates for #{new_resource.remote}") do
           # since we're in a local branch already, just reset to specified revision rather than merge
           Chef::Log.debug "Fetching updates from #{new_resource.remote} and resetting to revision #{target_revision}"
-          git("fetch", @new_resource.remote, cwd: cwd)
-          git("fetch", @new_resource.remote, "--tags", cwd: cwd)
+          git("fetch", new_resource.remote, cwd: cwd)
+          git("fetch", new_resource.remote, "--tags", cwd: cwd)
           git("reset", "--hard", target_revision, cwd: cwd)
         end
       end
 
       def setup_remote_tracking_branches(remote_name, remote_url)
         converge_by("set up remote tracking branches for #{remote_url} at #{remote_name}") do
-          Chef::Log.debug "#{@new_resource} configuring remote tracking branches for repository #{remote_url} " + "at remote #{remote_name}"
+          Chef::Log.debug "#{new_resource} configuring remote tracking branches for repository #{remote_url} " + "at remote #{remote_name}"
           check_remote_command = ["config", "--get", "remote.#{remote_name}.url"]
           remote_status = git(check_remote_command, cwd: cwd, returns: [0, 1, 2])
           case remote_status.exitstatus
@@ -219,13 +215,13 @@ class Chef
       end
 
       def current_revision_matches_target_revision?
-        (!@current_resource.revision.nil?) && (target_revision.strip.to_i(16) == @current_resource.revision.strip.to_i(16))
+        (!current_resource.revision.nil?) && (target_revision.strip.to_i(16) == current_resource.revision.strip.to_i(16))
       end
 
       def target_revision
         @target_revision ||= begin
-          if sha_hash?(@new_resource.revision)
-            @target_revision = @new_resource.revision
+          if sha_hash?(new_resource.revision)
+            @target_revision = new_resource.revision
           else
             @target_revision = remote_resolve_reference
           end
@@ -235,7 +231,7 @@ class Chef
       alias :revision_slug :target_revision
 
       def remote_resolve_reference
-        Chef::Log.debug("#{@new_resource} resolving remote reference")
+        Chef::Log.debug("#{new_resource} resolving remote reference")
         # The sha pointed to by an annotated tag is identified by the
         # '^{}' suffix appended to the tag. In order to resolve
         # annotated tags, we have to search for "revision*" and
@@ -250,11 +246,11 @@ class Chef
         # confusing. We avoid the issue by disallowing the use of
         # annotated tags named 'HEAD'.
         if rev_search_pattern != "HEAD"
-          found = find_revision(refs, @new_resource.revision, "^{}")
+          found = find_revision(refs, new_resource.revision, "^{}")
         else
           found = refs_search(refs, "HEAD")
         end
-        found = find_revision(refs, @new_resource.revision) if found.empty?
+        found = find_revision(refs, new_resource.revision) if found.empty?
         found.size == 1 ? found.first[0] : nil
       end
 
@@ -274,15 +270,15 @@ class Chef
       end
 
       def rev_search_pattern
-        if ["", "HEAD"].include? @new_resource.revision
+        if ["", "HEAD"].include? new_resource.revision
           "HEAD"
         else
-          @new_resource.revision + "*"
+          new_resource.revision + "*"
         end
       end
 
       def git_ls_remote(rev_pattern)
-        git("ls-remote", "\"#{@new_resource.repository}\"", "\"#{rev_pattern}\"").stdout
+        git("ls-remote", "\"#{new_resource.repository}\"", "\"#{rev_pattern}\"").stdout
       end
 
       def refs_search(refs, pattern)
@@ -293,28 +289,28 @@ class Chef
 
       def run_options(run_opts = {})
         env = {}
-        if @new_resource.user
-          run_opts[:user] = @new_resource.user
+        if new_resource.user
+          run_opts[:user] = new_resource.user
           # Certain versions of `git` misbehave if git configuration is
           # inaccessible in $HOME. We need to ensure $HOME matches the
           # user who is executing `git` not the user running Chef.
           env["HOME"] = begin
             require "etc"
-            case @new_resource.user
+            case new_resource.user
             when Integer
-              Etc.getpwuid(@new_resource.user).dir
+              Etc.getpwuid(new_resource.user).dir
             else
-              Etc.getpwnam(@new_resource.user.to_s).dir
+              Etc.getpwnam(new_resource.user.to_s).dir
             end
           rescue ArgumentError # user not found
-            raise Chef::Exceptions::User, "Could not determine HOME for specified user '#{@new_resource.user}' for resource '#{@new_resource.name}'"
+            raise Chef::Exceptions::User, "Could not determine HOME for specified user '#{new_resource.user}' for resource '#{new_resource.name}'"
           end
         end
-        run_opts[:group] = @new_resource.group if @new_resource.group
-        env["GIT_SSH"] = @new_resource.ssh_wrapper if @new_resource.ssh_wrapper
-        run_opts[:log_tag] = @new_resource.to_s
-        run_opts[:timeout] = @new_resource.timeout if @new_resource.timeout
-        env.merge!(@new_resource.environment) if @new_resource.environment
+        run_opts[:group] = new_resource.group if new_resource.group
+        env["GIT_SSH"] = new_resource.ssh_wrapper if new_resource.ssh_wrapper
+        run_opts[:log_tag] = new_resource.to_s
+        run_opts[:timeout] = new_resource.timeout if new_resource.timeout
+        env.merge!(new_resource.environment) if new_resource.environment
         run_opts[:environment] = env unless env.empty?
         run_opts
       end

data/lib/chef/provider/group.rb

@@ -1,6 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,21 +18,15 @@
 
 require "chef/provider"
 require "chef/mixin/shell_out"
-require "chef/mixin/command"
 require "etc"
 
 class Chef
   class Provider
     class Group < Chef::Provider
       include Chef::Mixin::ShellOut
-      include Chef::Mixin::Command
       attr_accessor :group_exists
       attr_accessor :change_desc
 
-      def whyrun_supported?
-        true
-      end
-
       def initialize(new_resource, run_context)
         super
         @group_exists = true

data/lib/chef/provider/http_request.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,83 +27,79 @@ class Chef
 
       attr_accessor :http
 
-      def whyrun_supported?
-        true
-      end
-
       def load_current_resource
-        @http = Chef::HTTP::Simple.new(@new_resource.url)
+        @http = Chef::HTTP::Simple.new(new_resource.url)
       end
 
-      # Send a HEAD request to @new_resource.url
+      # Send a HEAD request to new_resource.url
       def action_head
-        message = check_message(@new_resource.message)
+        message = check_message(new_resource.message)
         # CHEF-4762: we expect a nil return value from Chef::HTTP for a "200 Success" response
         # and false for a "304 Not Modified" response
         modified = @http.head(
-          "#{@new_resource.url}",
-          @new_resource.headers
+          "#{new_resource.url}",
+          new_resource.headers
         )
-        Chef::Log.info("#{@new_resource} HEAD to #{@new_resource.url} successful")
-        Chef::Log.debug("#{@new_resource} HEAD request response: #{modified}")
+        Chef::Log.info("#{new_resource} HEAD to #{new_resource.url} successful")
+        Chef::Log.debug("#{new_resource} HEAD request response: #{modified}")
         # :head is usually used to trigger notifications, which converge_by now does
         if modified != false
-          converge_by("#{@new_resource} HEAD to #{@new_resource.url} returned modified, trigger notifications") {}
+          converge_by("#{new_resource} HEAD to #{new_resource.url} returned modified, trigger notifications") {}
         end
       end
 
-      # Send a GET request to @new_resource.url
+      # Send a GET request to new_resource.url
       def action_get
-        converge_by("#{@new_resource} GET to #{@new_resource.url}") do
+        converge_by("#{new_resource} GET to #{new_resource.url}") do
 
-          message = check_message(@new_resource.message)
+          message = check_message(new_resource.message)
           body = @http.get(
-            "#{@new_resource.url}",
-            @new_resource.headers
+            "#{new_resource.url}",
+            new_resource.headers
           )
-          Chef::Log.info("#{@new_resource} GET to #{@new_resource.url} successful")
-          Chef::Log.debug("#{@new_resource} GET request response: #{body}")
+          Chef::Log.info("#{new_resource} GET to #{new_resource.url} successful")
+          Chef::Log.debug("#{new_resource} GET request response: #{body}")
         end
       end
 
-      # Send a PUT request to @new_resource.url, with the message as the payload
+      # Send a PUT request to new_resource.url, with the message as the payload
       def action_put
-        converge_by("#{@new_resource} PUT to #{@new_resource.url}") do
-          message = check_message(@new_resource.message)
+        converge_by("#{new_resource} PUT to #{new_resource.url}") do
+          message = check_message(new_resource.message)
           body = @http.put(
-            "#{@new_resource.url}",
+            "#{new_resource.url}",
             message,
-            @new_resource.headers
+            new_resource.headers
           )
-          Chef::Log.info("#{@new_resource} PUT to #{@new_resource.url} successful")
-          Chef::Log.debug("#{@new_resource} PUT request response: #{body}")
+          Chef::Log.info("#{new_resource} PUT to #{new_resource.url} successful")
+          Chef::Log.debug("#{new_resource} PUT request response: #{body}")
         end
       end
 
-      # Send a POST request to @new_resource.url, with the message as the payload
+      # Send a POST request to new_resource.url, with the message as the payload
       def action_post
-        converge_by("#{@new_resource} POST to #{@new_resource.url}") do
-          message = check_message(@new_resource.message)
+        converge_by("#{new_resource} POST to #{new_resource.url}") do
+          message = check_message(new_resource.message)
           body = @http.post(
-            "#{@new_resource.url}",
+            "#{new_resource.url}",
             message,
-            @new_resource.headers
+            new_resource.headers
           )
-          Chef::Log.info("#{@new_resource} POST to #{@new_resource.url} message: #{message.inspect} successful")
-          Chef::Log.debug("#{@new_resource} POST request response: #{body}")
+          Chef::Log.info("#{new_resource} POST to #{new_resource.url} message: #{message.inspect} successful")
+          Chef::Log.debug("#{new_resource} POST request response: #{body}")
         end
       end
 
-      # Send a DELETE request to @new_resource.url
+      # Send a DELETE request to new_resource.url
       def action_delete
-        converge_by("#{@new_resource} DELETE to #{@new_resource.url}") do
+        converge_by("#{new_resource} DELETE to #{new_resource.url}") do
           body = @http.delete(
-            "#{@new_resource.url}",
-            @new_resource.headers
+            "#{new_resource.url}",
+            new_resource.headers
           )
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} DELETE to #{@new_resource.url} successful")
-          Chef::Log.debug("#{@new_resource} DELETE request response: #{body}")
+          new_resource.updated_by_last_action(true)
+          Chef::Log.info("#{new_resource} DELETE to #{new_resource.url} successful")
+          Chef::Log.debug("#{new_resource} DELETE request response: #{body}")
         end
       end
 

data/lib/chef/provider/ifconfig/redhat.rb

@@ -22,7 +22,7 @@ class Chef
   class Provider
     class Ifconfig
       class Redhat < Chef::Provider::Ifconfig
-        provides :ifconfig, platform_family: %w{fedora rhel}
+        provides :ifconfig, platform_family: %w{fedora rhel amazon}
 
         def initialize(new_resource, run_context)
           super(new_resource, run_context)

data/lib/chef/provider/ifconfig.rb

@@ -17,7 +17,6 @@
 #
 
 require "chef/log"
-require "chef/mixin/command"
 require "chef/mixin/shell_out"
 require "chef/provider"
 require "chef/resource/file"
@@ -42,7 +41,6 @@ class Chef
       provides :ifconfig
 
       include Chef::Mixin::ShellOut
-      include Chef::Mixin::Command
 
       attr_accessor :config_template
       attr_accessor :config_path
@@ -53,10 +51,6 @@ class Chef
         @config_path = nil
       end
 
-      def whyrun_supported?
-        true
-      end
-
       def load_current_resource
         @current_resource = Chef::Resource::Ifconfig.new(new_resource.name)
 

data/lib/chef/provider/launchd.rb

@@ -30,7 +30,7 @@ class Chef
       extend Forwardable
       provides :launchd, os: "darwin"
 
-      def_delegators :@new_resource, *[
+      def_delegators :new_resource, *[
         :backup,
         :cookbook,
         :group,
@@ -85,6 +85,10 @@ class Chef
         manage_service(:disable)
       end
 
+      def action_restart
+        manage_service(:restart)
+      end
+
       def manage_plist(action)
         if source
           res = cookbook_file_resource
@@ -150,7 +154,7 @@ class Chef
       end
 
       def content
-        plist_hash = new_resource.hash || gen_hash
+        plist_hash = new_resource.plist_hash || gen_hash
         Plist::Emit.dump(plist_hash) unless plist_hash.nil?
       end