chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/lib/chef/knife/bootstrap/client_builder.rb

@@ -20,6 +20,7 @@ require 'chef/node'
 require 'chef/rest'
 require 'chef/api_client/registration'
 require 'chef/api_client'
+require 'chef/knife/bootstrap'
 require 'tmpdir'
 
 class Chef
@@ -90,6 +91,16 @@ class Chef
           knife_config[:run_list]
         end
 
+        # @return [String] policy_name from the knife_config
+        def policy_name
+          knife_config[:policy_name]
+        end
+
+        # @return [String] policy_group from the knife_config
+        def policy_group
+          knife_config[:policy_group]
+        end
+
         # @return [Hash,Array] Object representation of json first-boot attributes from the knife_config
         def first_boot_attributes
           knife_config[:first_boot_attributes]
@@ -140,6 +151,11 @@ class Chef
               node.run_list(normalized_run_list)
               node.normal_attrs = first_boot_attributes if first_boot_attributes
               node.environment(environment) if environment
+              node.policy_name = policy_name if policy_name
+              node.policy_group = policy_group if policy_group
+              (knife_config[:tags] || []).each do |tag|
+                node.tags << tag
+              end
               node
             end
         end

data/lib/chef/knife/bootstrap/templates/README.md

@@ -1,12 +1,11 @@
 This directory contains bootstrap templates which can be used with the -d flag
 to 'knife bootstrap' to install Chef in different ways. To simplify installation,
 and reduce the matrix of common installation patterns to support, we have
-standardized on the [Omnibus](https://github.com/opscode/omnibus-ruby) built installation 
+standardized on the [Omnibus](https://github.com/chef/omnibus) built installation
 packages.
 
 The 'chef-full' template downloads a script which is used to determine the correct
-Omnibus package for this system from the [Omnitruck](https://github.com/opscode/opscode-omnitruck) API. All other templates in this directory are deprecated and will be removed
-in the future.
+Omnibus package for this system from the [Omnitruck](https://docs.chef.io/api_omnitruck.html) API.
 
 You can still utilize custom bootstrap templates on your system if your installation
-needs are unique. Additional information can be found on the [docs site](http://docs.opscode.com/knife_bootstrap.html#custom-templates).
+needs are unique. Additional information can be found on the [docs site](https://docs.chef.io/knife_bootstrap.html#custom-templates).

data/lib/chef/knife/bootstrap/templates/chef-full.erb

@@ -226,6 +226,6 @@ cat > /etc/chef/first-boot.json <<EOP
 <%= Chef::JSONCompat.to_json(first_boot) %>
 EOP
 
-echo "Starting first Chef Client run..."
+echo "Starting the first Chef Client run..."
 
 <%= start_chef %>'

data/lib/chef/knife/cookbook_create.rb

@@ -48,7 +48,7 @@ class Chef
       option :cookbook_copyright,
         :short => "-C COPYRIGHT",
         :long => "--copyright COPYRIGHT",
-        :description => "Name of Copyright holder"
+        :description => "Name of copyright holder"
 
       option :cookbook_email,
         :short => "-m EMAIL",

data/lib/chef/knife/cookbook_site_download.rb

@@ -84,7 +84,7 @@ class Chef
       end
 
       def download_cookbook
-        ui.info "Downloading #{@name_args[0]} from the cookbooks site at version #{version} to #{download_location}"
+        ui.info "Downloading #{@name_args[0]} from Supermarket at version #{version} to #{download_location}"
         noauth_rest.sign_on_redirect = false
         tf = noauth_rest.get_rest desired_cookbook_data["file"], true
 

data/lib/chef/knife/cookbook_site_install.rb

@@ -93,7 +93,7 @@ class Chef
 
         # TODO: it'd be better to store these outside the cookbook repo and
         # keep them around, e.g., in ~/Library/Caches on OS X.
-        ui.info("removing downloaded tarball")
+        ui.info("Removing downloaded tarball")
         File.unlink(upstream_file)
 
         if @repo.finalize_updates_to(@cookbook_name, downloader.version)

data/lib/chef/knife/cookbook_site_share.rb

@@ -48,7 +48,7 @@ class Chef
         :short => '-n',
         :boolean => true,
         :default => false,
-        :description => "Don't take action, only print what files will be upload to SuperMarket."
+        :description => "Don't take action, only print what files will be uploaded to Supermarket."
 
       def run
         config[:cookbook_path] ||= Chef::Config[:cookbook_path]
@@ -94,7 +94,7 @@ class Chef
             Chef::Log.debug("Removing local staging directory at #{tmp_cookbook_dir}")
             FileUtils.rm_rf tmp_cookbook_dir
           rescue => e
-            ui.error("Error uploading cookbook #{cookbook_name} to the Opscode Cookbook Site: #{e.message}. Increase log verbosity (-VV) for more information.")
+            ui.error("Error uploading cookbook #{cookbook_name} to Supermarket: #{e.message}. Increase log verbosity (-VV) for more information.")
             Chef::Log.debug("\n#{e.backtrace.join("\n")}")
             exit(1)
           end
@@ -108,15 +108,15 @@ class Chef
 
       def get_category(cookbook_name)
         begin
-          data = noauth_rest.get_rest("http://cookbooks.opscode.com/api/v1/cookbooks/#{@name_args[0]}")
+          data = noauth_rest.get_rest("https://supermarket.chef.io/api/v1/cookbooks/#{@name_args[0]}")
           if !data["category"] && data["error_code"]
-            ui.fatal("Received an error from the Opscode Cookbook site: #{data["error_code"]}. On the first time you upload it, you are required to specify the category you want to share this cookbook to.")
+            ui.fatal("Received an error from Supermarket: #{data["error_code"]}. On the first time you upload it, you are required to specify the category you want to share this cookbook to.")
             exit(1)
           else
             data['category']
           end
         rescue => e
-          ui.fatal("Unable to reach Opscode Cookbook Site: #{e.message}. Increase log verbosity (-VV) for more information.")
+          ui.fatal("Unable to reach Supermarket: #{e.message}. Increase log verbosity (-VV) for more information.")
           Chef::Log.debug("\n#{e.backtrace.join("\n")}")
           exit(1)
         end
@@ -136,7 +136,7 @@ class Chef
         if http_resp.code.to_i != 201
           if res['error_messages']
             if res['error_messages'][0] =~ /Version already exists/
-              ui.error "The same version of this cookbook already exists on the Opscode Cookbook Site."
+              ui.error "The same version of this cookbook already exists on Supermarket."
               exit(1)
             else
               ui.error "#{res['error_messages'][0]}"

data/lib/chef/knife/cookbook_site_unshare.rb

@@ -38,7 +38,7 @@ class Chef
           exit 1
         end
 
-        confirm "Do you really want to unshare the cookbook #{@cookbook_name}"
+        confirm "Do you really want to unshare all versions of the cookbook #{@cookbook_name}"
 
         begin
           rest.delete_rest "https://supermarket.chef.io/api/v1/cookbooks/#{@name_args[0]}"
@@ -48,7 +48,7 @@ class Chef
           exit 1
         end
 
-        ui.info "Unshared cookbook #{@cookbook_name}"
+        ui.info "Unshared all versions of the cookbook #{@cookbook_name}"
       end
 
     end

data/lib/chef/knife/core/bootstrap_context.rb

@@ -40,7 +40,7 @@ class Chef
         end
 
         def bootstrap_environment
-          @chef_config[:environment] || '_default'
+          @chef_config[:environment]
         end
 
         def validation_key
@@ -128,7 +128,7 @@ CONFIG
           client_path = @chef_config[:chef_client_path] || 'chef-client'
           s = "#{client_path} -j /etc/chef/first-boot.json"
           s << ' -l debug' if @config[:verbosity] and @config[:verbosity] >= 2
-          s << " -E #{bootstrap_environment}"
+          s << " -E #{bootstrap_environment}" unless bootstrap_environment.nil?
           s
         end
 
@@ -163,11 +163,19 @@ CONFIG
         end
 
         def first_boot
-          (@config[:first_boot_attributes] || {}).merge(:run_list => @run_list)
+          (@config[:first_boot_attributes] || {}).tap do |attributes|
+            if @config[:policy_name] && @config[:policy_group]
+              attributes.merge!(:policy_name => @config[:policy_name], :policy_group => @config[:policy_group])
+            else
+              attributes.merge!(:run_list => @run_list)
+            end
+
+            attributes.merge!(:tags => @config[:tags]) if @config[:tags] && !@config[:tags].empty?
+          end
         end
 
         private
-       
+
         # Returns a string for copying the trusted certificates on the workstation to the system being bootstrapped
         # This string should contain both the commands necessary to both create the files, as well as their content
         def trusted_certs_content

data/lib/chef/knife/core/custom_manifest_loader.rb

@@ -0,0 +1,69 @@
+# Copyright:: Copyright (c) 2015 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 'chef/version'
+class Chef
+  class Knife
+    class SubcommandLoader
+
+      #
+      # Load a subcommand from a user-supplied
+      # manifest file
+      #
+      class CustomManifestLoader < Chef::Knife::SubcommandLoader
+        attr_accessor :manifest
+        def initialize(chef_config_dir, plugin_manifest)
+          super(chef_config_dir)
+          @manifest = plugin_manifest
+        end
+
+        # If the user has created a ~/.chef/plugin_manifest.json file, we'll use
+        # that instead of inspecting the on-system gems to find the plugins. The
+        # file format is expected to look like:
+        #
+        #   { "plugins": {
+        #       "knife-ec2": {
+        #         "paths": [
+        #           "/home/alice/.rubymanagerthing/gems/knife-ec2-x.y.z/lib/chef/knife/ec2_server_create.rb",
+        #           "/home/alice/.rubymanagerthing/gems/knife-ec2-x.y.z/lib/chef/knife/ec2_server_delete.rb"
+        #         ]
+        #       }
+        #     }
+        #   }
+        #
+        # Extraneous content in this file is ignored. This is intentional so that we
+        # can adapt the file format for potential behavior changes to knife in
+        # the future.
+        def find_subcommands_via_manifest
+          # Format of subcommand_files is "relative_path" (something you can
+          # Kernel.require()) => full_path. The relative path isn't used
+          # currently, so we just map full_path => full_path.
+          subcommand_files = {}
+          manifest["plugins"].each do |plugin_name, plugin_manifest|
+            plugin_manifest["paths"].each do |cmd_path|
+              subcommand_files[cmd_path] = cmd_path
+            end
+          end
+          subcommand_files.merge(find_subcommands_via_dirglob)
+        end
+
+        def subcommand_files
+          subcommand_files ||= (find_subcommands_via_manifest.values + site_subcommands).flatten.uniq
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/core/gem_glob_loader.rb

@@ -0,0 +1,138 @@
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009-2015 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 'chef/version'
+require 'chef/util/path_helper'
+class Chef
+  class Knife
+    class SubcommandLoader
+      class GemGlobLoader < Chef::Knife::SubcommandLoader
+        MATCHES_CHEF_GEM = %r{/chef-[\d]+\.[\d]+\.[\d]+}.freeze
+        MATCHES_THIS_CHEF_GEM = %r{/chef-#{Chef::VERSION}(-\w+)?(-\w+)?/}.freeze
+
+        def subcommand_files
+          @subcommand_files ||= (gem_and_builtin_subcommands.values + site_subcommands).flatten.uniq
+        end
+
+        # Returns a Hash of paths to knife commands built-in to chef, or installed via gem.
+        # If rubygems is not installed, falls back to globbing the knife directory.
+        # The Hash is of the form {"relative/path" => "/absolute/path"}
+        #--
+        # Note: the "right" way to load the plugins is to require the relative path, i.e.,
+        #   require 'chef/knife/command'
+        # but we're getting frustrated by bugs at every turn, and it's slow besides. So
+        # subcommand loader has been modified to load the plugins by using Kernel.load
+        # with the absolute path.
+        def gem_and_builtin_subcommands
+          require 'rubygems'
+          find_subcommands_via_rubygems
+        rescue LoadError
+          find_subcommands_via_dirglob
+        end
+
+        def find_subcommands_via_dirglob
+          # The "require paths" of the core knife subcommands bundled with chef
+          files = Dir[File.join(Chef::Util::PathHelper.escape_glob(File.expand_path('../../../knife', __FILE__)), '*.rb')]
+          subcommand_files = {}
+          files.each do |knife_file|
+            rel_path = knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1]
+            subcommand_files[rel_path] = knife_file
+          end
+          subcommand_files
+        end
+
+        def find_subcommands_via_rubygems
+          files = find_files_latest_gems 'chef/knife/*.rb'
+          subcommand_files = {}
+          files.each do |file|
+            rel_path = file[/(#{Regexp.escape File.join('chef', 'knife', '')}.*)\.rb/, 1]
+
+            # When not installed as a gem (ChefDK/appbundler in particular), AND
+            # a different version of Chef is installed via gems, `files` will
+            # include some files from the 'other' Chef install. If this contains
+            # a knife command that doesn't exist in this version of Chef, we will
+            # get a LoadError later when we try to require it.
+            next if from_different_chef_version?(file)
+
+            subcommand_files[rel_path] = file
+          end
+
+          subcommand_files.merge(find_subcommands_via_dirglob)
+        end
+
+        private
+
+        def find_files_latest_gems(glob, check_load_path=true)
+          files = []
+
+          if check_load_path
+            files = $LOAD_PATH.map { |load_path|
+              Dir["#{File.expand_path glob, Chef::Util::PathHelper.escape_glob(load_path)}#{Gem.suffix_pattern}"]
+            }.flatten.select { |file| File.file? file.untaint }
+          end
+
+          gem_files = latest_gem_specs.map do |spec|
+            # Gem::Specification#matches_for_glob wasn't added until RubyGems 1.8
+            if spec.respond_to? :matches_for_glob
+              spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
+            else
+              check_spec_for_glob(spec, glob)
+            end
+          end.flatten
+
+          files.concat gem_files
+          files.uniq! if check_load_path
+
+          return files
+        end
+
+        def latest_gem_specs
+          @latest_gem_specs ||= if Gem::Specification.respond_to? :latest_specs
+                                  Gem::Specification.latest_specs(true)  # find prerelease gems
+                                else
+                                  Gem.source_index.latest_specs(true)
+                                end
+        end
+
+        def check_spec_for_glob(spec, glob)
+          dirs = if spec.require_paths.size > 1 then
+                   "{#{spec.require_paths.join(',')}}"
+                 else
+                   spec.require_paths.first
+                 end
+
+          glob = File.join(Chef::Util::PathHelper.escape_glob(spec.full_gem_path, dirs), glob)
+
+          Dir[glob].map { |f| f.untaint }
+        end
+
+        def from_different_chef_version?(path)
+          matches_any_chef_gem?(path) && !matches_this_chef_gem?(path)
+        end
+
+        def matches_any_chef_gem?(path)
+          path =~ MATCHES_CHEF_GEM
+        end
+
+        def matches_this_chef_gem?(path)
+          path =~ MATCHES_THIS_CHEF_GEM
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/core/hashed_command_loader.rb

@@ -0,0 +1,80 @@
+# Author:: Steven Danna (<steve@chef.io>)
+# Copyright:: Copyright (c) 2015 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 'chef/version'
+class Chef
+  class Knife
+    class SubcommandLoader
+      #
+      # Load a subcommand from a pre-computed path
+      # for the given command.
+      #
+      class HashedCommandLoader < Chef::Knife::SubcommandLoader
+        KEY = '_autogenerated_command_paths'
+
+        attr_accessor :manifest
+        def initialize(chef_config_dir, plugin_manifest)
+          super(chef_config_dir)
+          @manifest = plugin_manifest
+        end
+
+        def guess_category(args)
+          category_words = positional_arguments(args)
+          category_words.map! { |w| w.split('-') }.flatten!
+          find_longest_key(manifest[KEY]["plugins_by_category"], category_words, ' ')
+        end
+
+        def list_commands(pref_category=nil)
+          if pref_category || manifest[KEY]["plugins_by_category"].key?(pref_category)
+            { pref_category => manifest[KEY]["plugins_by_category"][pref_category] }
+          else
+            manifest[KEY]["plugins_by_category"]
+          end
+        end
+
+        def subcommand_files
+          manifest[KEY]["plugins_paths"].values.flatten
+        end
+
+        def load_command(args)
+          paths = manifest[KEY]["plugins_paths"][subcommand_for_args(args)]
+          if paths.nil? || paths.empty? || (! paths.is_a? Array)
+            false
+          else
+            paths.each do |sc|
+              if File.exists?(sc)
+                Kernel.load sc
+              else
+                Chef::Log.error "The file #{sc} is missing for subcommand '#{subcommand_for_args(args)}'. Please rehash to update the subcommands cache."
+                return false
+              end
+            end
+            true
+          end
+        end
+
+        def subcommand_for_args(args)
+          if manifest[KEY]["plugins_paths"].key?(args)
+            args
+          else
+            find_longest_key(manifest[KEY]["plugins_paths"], args, "_")
+          end
+        end
+      end
+    end
+  end
+end