chef 11.6.2-x86-mingw32 → 11.8.0.rc.1-x86-mingw32

data/lib/chef/application/knife.rb

@@ -106,6 +106,16 @@ class Chef::Application::Knife < Chef::Application
     :description => "Which format to use for output",
     :default => "summary"
 
+  option :local_mode,
+    :short        => "-z",
+    :long         => "--local-mode",
+    :description  => "Point knife commands at local repository instead of server",
+    :boolean      => true
+
+  option :chef_zero_port,
+    :long         => "--chef-zero-port PORT",
+    :description  => "Port to start chef-zero on"
+
   option :version,
     :short        => "-v",
     :long         => "--version",

data/lib/chef/application/solo.rb

@@ -23,7 +23,7 @@ require 'chef/config'
 require 'chef/daemon'
 require 'chef/log'
 require 'chef/rest'
-require 'open-uri'
+require 'chef/config_fetcher'
 require 'fileutils'
 
 class Chef::Application::Solo < Chef::Application
@@ -31,7 +31,7 @@ class Chef::Application::Solo < Chef::Application
   option :config_file,
     :short => "-c CONFIG",
     :long  => "--config CONFIG",
-    :default => Chef::Config.platform_specfic_path('/etc/chef/solo.rb'),
+    :default => Chef::Config.platform_specific_path('/etc/chef/solo.rb'),
     :description => "The configuration file to use"
 
   option :formatter,
@@ -160,6 +160,11 @@ class Chef::Application::Solo < Chef::Application
     :description  => 'Enable whyrun mode',
     :boolean      => true
 
+  option :environment,
+    :short        => '-E ENVIRONMENT',
+    :long         => '--environment ENVIRONMENT',
+    :description  => 'Set the Chef Environment on the node'
+
   attr_reader :chef_solo_json
 
   def initialize
@@ -176,36 +181,13 @@ class Chef::Application::Solo < Chef::Application
     end
 
     if Chef::Config[:json_attribs]
-      begin
-        json_io = case Chef::Config[:json_attribs]
-                  when /^(http|https):\/\//
-                    @rest = Chef::REST.new(Chef::Config[:json_attribs], nil, nil)
-                    @rest.get_rest(Chef::Config[:json_attribs], true).open
-                  else
-                    open(Chef::Config[:json_attribs])
-                  end
-      rescue SocketError => error
-        Chef::Application.fatal!("I cannot connect to #{Chef::Config[:json_attribs]}", 2)
-      rescue Errno::ENOENT => error
-        Chef::Application.fatal!("I cannot find #{Chef::Config[:json_attribs]}", 2)
-      rescue Errno::EACCES => error
-        Chef::Application.fatal!("Permissions are incorrect on #{Chef::Config[:json_attribs]}. Please chmod a+r #{Chef::Config[:json_attribs]}", 2)
-      rescue Exception => error
-        Chef::Application.fatal!("Got an unexpected error reading #{Chef::Config[:json_attribs]}: #{error.message}", 2)
-      end
-
-      begin
-        @chef_client_json = Chef::JSONCompat.from_json(json_io.read)
-        json_io.close unless json_io.closed?
-      rescue JSON::ParserError => error
-        Chef::Application.fatal!("Could not parse the provided JSON file (#{Chef::Config[:json_attribs]})!: " + error.message, 2)
-      end
+      config_fetcher = Chef::ConfigFetcher.new(Chef::Config[:json_attribs])
+      @chef_solo_json = config_fetcher.fetch_json
     end
 
     if Chef::Config[:recipe_url]
       cookbooks_path = Array(Chef::Config[:cookbook_path]).detect{|e| e =~ /\/cookbooks\/*$/ }
       recipes_path = File.expand_path(File.join(cookbooks_path, '..'))
-      target_file = File.join(recipes_path, 'recipes.tgz')
 
       Chef::Log.debug "Creating path #{recipes_path} to extract recipes into"
       FileUtils.mkdir_p recipes_path

data/lib/chef/application/windows_service.rb

@@ -27,11 +27,13 @@ require 'chef/rest'
 require 'mixlib/cli'
 require 'socket'
 require 'win32/daemon'
+require 'chef/mixin/shell_out'
 
 class Chef
   class Application
     class WindowsService < ::Win32::Daemon
       include Mixlib::CLI
+      include Chef::Mixin::ShellOut
 
       option :config_file,
         :short => "-c CONFIG",
@@ -160,17 +162,29 @@ class Chef
 
       # 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
+        # The chef client will be started in a new process. We have used shell_out to start the chef-client.
+        # The log_location and config_file of the parent process is passed to the new chef-client process.
+        # We need to add the --no-fork, as by default it is set to fork=true.
+        begin
+          Chef::Log.info "Starting chef-client in a new process"
+          # Pass config params to the new process
+          config_params = " --no-fork"
+          config_params += " -c #{Chef::Config[:config_file]}" unless  Chef::Config[:config_file].nil?
+          config_params += " -L #{Chef::Config[:log_location]}" unless Chef::Config[:log_location] == STDOUT
+          # Starts a new process and waits till the process exits
+          result = shell_out("chef-client #{config_params}")
+          Chef::Log.debug "#{result.stdout}"
+          Chef::Log.debug "#{result.stderr}"
+        rescue Mixlib::ShellOut::ShellCommandFailed => e
+          Chef::Log.warn "Not able to start chef-client in new process (#{e})"
+        rescue => e
+          Chef::Log.error e
+        ensure
+          # Once process exits, we log the current process' pid
+          Chef::Log.info "Child process exited (pid: #{Process.pid})"
+        end
       end
 
-
       def apply_config(config_file_path)
         Chef::Config.from_file(config_file_path)
         Chef::Config.merge!(config)
@@ -241,7 +255,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 the Services manager
+        # It is also possible to specify startup parameters separately, either via 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

data/lib/chef/application/windows_service_manager.rb

@@ -61,6 +61,14 @@ class Chef
         :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
+
       def initialize(service_options)
         # having to call super in initialize is the most annoying
         # anti-pattern :(

data/lib/chef/checksum/storage.rb

@@ -6,9 +6,9 @@
 # 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.

data/lib/chef/checksum/storage/filesystem.rb

@@ -6,9 +6,9 @@
 # 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.

data/lib/chef/chef_fs/chef_fs_data_store.rb

@@ -135,7 +135,7 @@ class Chef
             if path[0] == 'cookbooks' && path.length >= 3
               entry.delete(true)
             else
-              entry.delete
+              entry.delete(false)
             end
           end
         end

data/lib/chef/chef_fs/command_line.rb

@@ -19,6 +19,7 @@
 require 'chef/chef_fs/file_system'
 require 'chef/chef_fs/file_system/operation_failed_error'
 require 'chef/chef_fs/file_system/operation_not_allowed_error'
+require 'chef/util/diff'
 
 class Chef
   module ChefFS
@@ -268,7 +269,7 @@ class Chef
             old_tempfile.write(old_value)
             old_tempfile.close
 
-            result = `diff -u #{old_tempfile.path} #{new_tempfile.path}`
+            result = Chef::Util::Diff.new.udiff(old_tempfile.path, new_tempfile.path)
             result = result.gsub(/^--- #{old_tempfile.path}/, "--- #{old_path}")
             result = result.gsub(/^\+\+\+ #{new_tempfile.path}/, "+++ #{new_path}")
             result

data/lib/chef/chef_fs/config.rb

@@ -25,13 +25,24 @@ class Chef
     # Helpers to take Chef::Config and create chef_fs and local_fs from it
     #
     class Config
-      def initialize(chef_config = Chef::Config, cwd = Dir.pwd)
+      def initialize(chef_config = Chef::Config, cwd = Dir.pwd, options = {})
         @chef_config = chef_config
         @cwd = cwd
-        configure_repo_paths
+        @cookbook_version = options[:cookbook_version]
+
+        # Default to getting *everything* from the server.
+        if !@chef_config[:repo_mode]
+          if @chef_config[:chef_server_url] =~ /\/+organizations\/.+/
+            @chef_config[:repo_mode] = 'hosted_everything'
+          else
+            @chef_config[:repo_mode] = 'everything'
+          end
+        end
       end
 
-      PATH_VARIABLES = %w(acl_path client_path cookbook_path container_path data_bag_path environment_path group_path node_path role_path user_path)
+      attr_reader :chef_config
+      attr_reader :cwd
+      attr_reader :cookbook_version
 
       def chef_fs
         @chef_fs ||= create_chef_fs
@@ -39,7 +50,7 @@ class Chef
 
       def create_chef_fs
         require 'chef/chef_fs/file_system/chef_server_root_dir'
-        Chef::ChefFS::FileSystem::ChefServerRootDir.new("remote", @chef_config)
+        Chef::ChefFS::FileSystem::ChefServerRootDir.new("remote", @chef_config, :cookbook_version => @cookbook_version)
       end
 
       def local_fs
@@ -73,16 +84,14 @@ class Chef
       # If the path does not reach into ANY specified directory, nil is returned.
       def server_path(file_path)
         pwd = File.expand_path(Dir.pwd)
-        absolute_path = Chef::ChefFS::PathUtils.realest_path(File.expand_path(file_path, pwd))
+        absolute_pwd = Chef::ChefFS::PathUtils.realest_path(File.expand_path(file_path, pwd))
 
         # Check all object paths (cookbooks_dir, data_bags_dir, etc.)
         object_paths.each_pair do |name, paths|
           paths.each do |path|
             realest_path = Chef::ChefFS::PathUtils.realest_path(path)
-            if absolute_path[0,realest_path.length] == realest_path &&
-              (absolute_path.length == realest_path.length ||
-                absolute_path[realest_path.length,1] =~ /#{PathUtils.regexp_path_separator}/)
-              relative_path = Chef::ChefFS::PathUtils::relative_to(absolute_path, realest_path)
+            if PathUtils.descendant_of?(absolute_pwd, realest_path)
+              relative_path = Chef::ChefFS::PathUtils::relative_to(absolute_pwd, realest_path)
               return relative_path == '.' ? "/#{name}" : "/#{name}/#{relative_path}"
             end
           end
@@ -91,7 +100,7 @@ class Chef
         # Check chef_repo_path
         Array(@chef_config[:chef_repo_path]).flatten.each do |chef_repo_path|
           realest_chef_repo_path = Chef::ChefFS::PathUtils.realest_path(chef_repo_path)
-          if absolute_path == realest_chef_repo_path
+          if absolute_pwd == realest_chef_repo_path
             return '/'
           end
         end
@@ -125,19 +134,10 @@ class Chef
         server_path
       end
 
-      def require_chef_repo_path
-        if !@chef_config[:chef_repo_path]
-          Chef::Log.error("Must specify either chef_repo_path or cookbook_path in Chef config file")
-          exit(1)
-        end
-      end
-
       private
 
       def object_paths
         @object_paths ||= begin
-          require_chef_repo_path
-
           result = {}
           case @chef_config[:repo_mode]
           when 'static'
@@ -155,51 +155,6 @@ class Chef
           result
         end
       end
-
-      def configure_repo_paths
-        # Smooth out some (for now) inappropriate defaults set by Chef
-        if @chef_config[:cookbook_path] == [ @chef_config.platform_specific_path("/var/chef/cookbooks"),
-                      @chef_config.platform_specific_path("/var/chef/site-cookbooks") ]
-          @chef_config[:cookbook_path] = nil
-        end
-        if @chef_config[:data_bag_path] == @chef_config.platform_specific_path('/var/chef/data_bags')
-          @chef_config[:data_bag_path] = nil
-        end
-        if @chef_config[:node_path] == '/var/chef/node'
-          @chef_config[:node_path] = nil
-        end
-        if @chef_config[:role_path] == @chef_config.platform_specific_path('/var/chef/roles')
-          @chef_config[:role_path] = nil
-        end
-
-        # Infer chef_repo_path from cookbook_path if not speciifed
-        if !@chef_config[:chef_repo_path]
-          if @chef_config[:cookbook_path]
-            @chef_config[:chef_repo_path] = Array(@chef_config[:cookbook_path]).flatten.map { |path| File.expand_path('..', path) }
-          end
-        end
-
-        # Default to getting *everything* from the server.
-        if !@chef_config[:repo_mode]
-          if @chef_config[:chef_server_url] =~ /\/+organizations\/.+/
-            @chef_config[:repo_mode] = 'hosted_everything'
-          else
-            @chef_config[:repo_mode] = 'everything'
-          end
-        end
-
-        # Infer any *_path variables that are not specified
-        if @chef_config[:chef_repo_path]
-          PATH_VARIABLES.each do |variable_name|
-            chef_repo_paths = Array(@chef_config[:chef_repo_path]).flatten
-            variable = variable_name.to_sym
-            if !@chef_config[variable]
-              # cookbook_path -> cookbooks
-              @chef_config[variable] = chef_repo_paths.map { |path| File.join(path, "#{variable_name[0..-6]}s") }
-            end
-          end
-        end
-      end
     end
   end
 end

data/lib/chef/chef_fs/data_handler/client_data_handler.rb

@@ -9,12 +9,11 @@ class Chef
           defaults = {
             'name' => remove_dot_json(entry.name),
             'clientname' => remove_dot_json(entry.name),
-            'orgname' => entry.org,
             'admin' => false,
             'validator' => false,
             'chef_type' => 'client'
           }
-          if entry.org
+          if entry.respond_to?(:org) && entry.org
             defaults['orgname'] = entry.org
           end
           result = normalize_hash(client, defaults)

data/lib/chef/chef_fs/file_system.rb

@@ -289,7 +289,7 @@ class Chef
                   ui.output "Deleted extra entry #{dest_path} (purge is on)" if ui
                 end
               else
-                Chef::Log.info("Not deleting extra entry #{dest_path} (purge is off)") if ui
+                ui.output ("Not deleting extra entry #{dest_path} (purge is off)") if ui
               end
             end
 
@@ -407,7 +407,7 @@ class Chef
         parent = entry.parent
         if parent && !parent.exists?
           parent_path = format_path.call(parent) if ui
-          parent_parent = get_or_create_parent(entry.parent, options, ui, format_path)
+          parent_parent = get_or_create_parent(parent, options, ui, format_path)
           if options[:dry_run]
             ui.output "Would create #{parent_path}" if ui
           else

data/lib/chef/chef_fs/file_system/acl_entry.rb

@@ -40,7 +40,7 @@ class Chef
           acls = data_handler.normalize(JSON.parse(file_contents, :create_additions => false), self)
           PERMISSIONS.each do |permission|
             begin
-              rest.put_rest("#{api_path}/#{permission}", { permission => acls[permission] })
+              rest.put("#{api_path}/#{permission}", { permission => acls[permission] })
             rescue Timeout::Error => e
               raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Timeout writing: #{e}"
             rescue Net::HTTPServerException => e

data/lib/chef/chef_fs/file_system/chef_repository_file_system_acls_dir.rb

@@ -0,0 +1,37 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 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/chef_fs/file_system/chef_repository_file_system_entry'
+require 'chef/chef_fs/file_system/acls_dir'
+require 'chef/chef_fs/data_handler/acl_data_handler'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class ChefRepositoryFileSystemAclsDir < ChefRepositoryFileSystemEntry
+        def initialize(name, parent, path = nil)
+          super(name, parent, path, Chef::ChefFS::DataHandler::AclDataHandler.new)
+        end
+
+        def can_have_child?(name, is_dir)
+          is_dir ? Chef::ChefFS::FileSystem::AclsDir::ENTITY_TYPES.include?(name) : name == 'organization.json'
+        end
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/file_system/chef_repository_file_system_cookbook_dir.rb

@@ -18,6 +18,7 @@
 
 require 'chef/chef_fs/file_system/chef_repository_file_system_cookbook_entry'
 require 'chef/chef_fs/file_system/cookbook_dir'
+require 'chef/chef_fs/file_system/not_found_error'
 require 'chef/cookbook/chefignore'
 require 'chef/cookbook/cookbook_version_loader'
 
@@ -51,13 +52,14 @@ class Chef
         end
 
         def children
-          Dir.entries(file_path).sort.
-              select { |child_name| can_have_child?(child_name, File.directory?(File.join(file_path, child_name))) }.
-              map do |child_name|
-                segment_info = CookbookDir::COOKBOOK_SEGMENT_INFO[child_name.to_sym] || {}
-                ChefRepositoryFileSystemCookbookEntry.new(child_name, self, nil, segment_info[:ruby_only], segment_info[:recursive])
-              end.
-              select { |entry| !(entry.dir? && entry.children.size == 0) }
+          begin
+            Dir.entries(file_path).sort.
+                select { |child_name| can_have_child?(child_name, File.directory?(File.join(file_path, child_name))) }.
+                map { |child_name| make_child(child_name) }.
+                select { |entry| !(entry.dir? && entry.children.size == 0) }
+          rescue Errno::ENOENT
+            raise Chef::ChefFS::FileSystem::NotFoundError.new(self, $!)
+          end
         end
 
         def can_have_child?(name, is_dir)
@@ -65,7 +67,6 @@ class Chef
             # Only the given directories will be uploaded.
             return CookbookDir::COOKBOOK_SEGMENT_INFO.keys.include?(name.to_sym) && name != 'root_files'
           end
-
           super(name, is_dir)
         end
 
@@ -79,6 +80,13 @@ class Chef
         def canonical_cookbook_name(entry_name)
           self.class.canonical_cookbook_name(entry_name)
         end
+
+        protected
+
+        def make_child(child_name)
+          segment_info = CookbookDir::COOKBOOK_SEGMENT_INFO[child_name.to_sym] || {}
+          ChefRepositoryFileSystemCookbookEntry.new(child_name, self, nil, segment_info[:ruby_only], segment_info[:recursive])
+        end
       end
     end
   end