chef 12.0.0.alpha.1 → 12.0.0.alpha.2

data/lib/chef/util/windows/net_user.rb

@@ -17,6 +17,7 @@
 #
 
 require 'chef/util/windows'
+require 'chef/exceptions'
 
 #wrapper around a subset of the NetUser* APIs.
 #nothing Chef specific, but not complete enough to be its own gem, so util for now.
@@ -137,7 +138,9 @@ class Chef::Util::Windows::NetUser < Chef::Util::Windows
     ptr  = 0.chr * PTR_SIZE
     rc = NetUserGetInfo.call(nil, @name, 3, ptr)
 
-    if rc != NERR_Success
+    if rc == NERR_UserNotFound
+      raise Chef::Exceptions::UserIDNotFound, get_last_error(rc)
+    elsif rc != NERR_Success
       raise ArgumentError, get_last_error(rc)
     end
 

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '12.0.0.alpha.1'
+  VERSION = '12.0.0.alpha.2'
 end
 
 #

data/lib/chef/win32/api/file.rb

@@ -459,11 +459,7 @@ BOOL WINAPI DeviceIoControl(
         # to be passed to the *W vesion of WinAPI File
         # functions
         def encode_path(path)
-          (path_prepender << path.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR)).to_wstring
-        end
-
-        def path_prepender
-          "\\\\?\\"
+          Chef::Util::PathHelper.canonical_path(path).to_wstring
         end
 
         # retrieves a file search handle and passes it

data/lib/chef/win32/api/net.rb

@@ -33,6 +33,7 @@ class Chef
         MAX_PREFERRED_LENGTH                = 0xFFFF
 
         NERR_Success                        = 0
+        NERR_UserNotFound                   = 2221
 
         ffi_lib "netapi32"
 

data/lib/chef/workstation_config_loader.rb

@@ -0,0 +1,177 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright (c) 2014 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/config_fetcher'
+require 'chef/config'
+require 'chef/null_logger'
+
+class Chef
+
+  class WorkstationConfigLoader
+
+    # Path to a config file requested by user, (e.g., via command line option). Can be nil
+    attr_reader :explicit_config_file
+
+    # TODO: initialize this with a logger for Chef and Knife
+    def initialize(explicit_config_file, logger=nil)
+      @explicit_config_file = explicit_config_file
+      @config_location = nil
+      @logger = logger || NullLogger.new
+    end
+
+    def no_config_found?
+      config_location.nil?
+    end
+
+    def config_location
+      @config_location ||= (explicit_config_file || locate_local_config)
+    end
+
+    def chef_config_dir
+      if @chef_config_dir.nil?
+        @chef_config_dir = false
+        full_path = working_directory.split(File::SEPARATOR)
+        (full_path.length - 1).downto(0) do |i|
+          candidate_directory = File.join(full_path[0..i] + [".chef" ])
+          if File.exist?(candidate_directory) && File.directory?(candidate_directory)
+            @chef_config_dir = candidate_directory
+            break
+          end
+        end
+      end
+      @chef_config_dir
+    end
+
+    def load
+      # Ignore it if there's no explicit_config_file and can't find one at a
+      # default path.
+      return false if config_location.nil?
+
+      if explicit_config_file && !path_exists?(config_location)
+        raise Exceptions::ConfigurationError, "Specified config file #{config_location} does not exist"
+      end
+
+      # Have to set Chef::Config.config_file b/c other config is derived from it.
+      Chef::Config.config_file = config_location
+      read_config(IO.read(config_location), config_location)
+    end
+
+    # (Private API, public for test purposes)
+    def env
+      ENV
+    end
+
+    # (Private API, public for test purposes)
+    def path_exists?(path)
+      Pathname.new(path).expand_path.exist?
+    end
+
+    private
+
+    def have_config?(path)
+      if path_exists?(path)
+        logger.info("Using config at #{path}")
+        true
+      else
+        logger.debug("Config not found at #{path}, trying next option")
+        false
+      end
+    end
+
+    def locate_local_config
+      candidate_configs = []
+
+      # Look for $KNIFE_HOME/knife.rb (allow multiple knives config on same machine)
+      if env['KNIFE_HOME']
+        candidate_configs << File.join(env['KNIFE_HOME'], 'config.rb')
+        candidate_configs << File.join(env['KNIFE_HOME'], 'knife.rb')
+      end
+      # Look for $PWD/knife.rb
+      if Dir.pwd
+        candidate_configs << File.join(Dir.pwd, 'config.rb')
+        candidate_configs << File.join(Dir.pwd, 'knife.rb')
+      end
+      # Look for $UPWARD/.chef/knife.rb
+      if chef_config_dir
+        candidate_configs << File.join(chef_config_dir, 'config.rb')
+        candidate_configs << File.join(chef_config_dir, 'knife.rb')
+      end
+      # Look for $HOME/.chef/knife.rb
+      if env['HOME']
+        candidate_configs << File.join(env['HOME'], '.chef', 'config.rb')
+        candidate_configs << File.join(env['HOME'], '.chef', 'knife.rb')
+      end
+
+      candidate_configs.find do | candidate_config |
+        have_config?(candidate_config)
+      end
+    end
+
+    def working_directory
+      a = if Chef::Platform.windows?
+            env['CD']
+          else
+            env['PWD']
+          end || Dir.pwd
+
+      a
+    end
+
+    def read_config(config_content, config_file_path)
+      Chef::Config.from_string(config_content, config_file_path)
+    rescue SignalException
+      raise
+    rescue SyntaxError => e
+      message = ""
+      message << "You have invalid ruby syntax in your config file #{config_file_path}\n\n"
+      message << "#{e.class.name}: #{e.message}\n"
+      if file_line = e.message[/#{Regexp.escape(config_file_path)}:[\d]+/]
+        line = file_line[/:([\d]+)$/, 1].to_i
+        message << highlight_config_error(config_file_path, line)
+      end
+      raise Exceptions::ConfigurationError, message
+    rescue Exception => e
+      message = "You have an error in your config file #{config_file_path}\n\n"
+      message << "#{e.class.name}: #{e.message}\n"
+      filtered_trace = e.backtrace.grep(/#{Regexp.escape(config_file_path)}/)
+      filtered_trace.each {|bt_line| message << "  " << bt_line << "\n" }
+      if !filtered_trace.empty?
+        line_nr = filtered_trace.first[/#{Regexp.escape(config_file_path)}:([\d]+)/, 1]
+        message << highlight_config_error(config_file_path, line_nr.to_i)
+      end
+      raise Exceptions::ConfigurationError, message
+    end
+
+
+    def highlight_config_error(file, line)
+      config_file_lines = []
+      IO.readlines(file).each_with_index {|l, i| config_file_lines << "#{(i + 1).to_s.rjust(3)}: #{l.chomp}"}
+      if line == 1
+        lines = config_file_lines[0..3]
+      else
+        lines = config_file_lines[Range.new(line - 2, line)]
+      end
+      "Relevant file content:\n" + lines.join("\n") + "\n"
+    end
+
+    def logger
+      @logger
+    end
+
+  end
+end

data/spec/functional/http/simple_spec.rb

@@ -80,5 +80,61 @@ describe Chef::HTTP::Simple do
   end
 
   it_behaves_like "downloading all the things"
-end
 
+  context "when Chef::Log.level = :debug" do
+    before do
+      Chef::Log.level = :debug
+      @debug_log = ''
+      Chef::Log.stub(:debug) { |str| @debug_log << str }
+    end
+
+    let(:source) { 'http://localhost:9000' }
+
+    it "Logs the request and response for 200's but not the body" do
+      http_client.get('http://localhost:9000/nyan_cat.png')
+      expect(@debug_log).to match(/200/)
+      expect(@debug_log).to match(/HTTP Request Header Data/)
+      expect(@debug_log).to match(/HTTP Status and Header Data/)
+      expect(@debug_log).not_to match(/HTTP Request Body/)
+      expect(@debug_log).not_to match(/HTTP Response Body/)
+      expect(@debug_log).not_to match(/Your request is just terrible./)
+    end
+
+    it "Logs the request and response for 200 POST, but not the body" do
+      http_client.post('http://localhost:9000/posty', 'hithere')
+      expect(@debug_log).to match(/200/)
+      expect(@debug_log).to match(/HTTP Request Header Data/)
+      expect(@debug_log).to match(/HTTP Status and Header Data/)
+      expect(@debug_log).not_to match(/HTTP Request Body/)
+      expect(@debug_log).not_to match(/hithere/)
+      expect(@debug_log).not_to match(/HTTP Response Body/)
+      expect(@debug_log).not_to match(/Your request is just terrible./)
+    end
+
+    it "Logs the request and response and bodies for 400 response" do
+      expect do
+        http_client.get('http://localhost:9000/bad_request')
+      end.to raise_error(Net::HTTPServerException)
+      expect(@debug_log).to match(/400/)
+      expect(@debug_log).to match(/HTTP Request Header Data/)
+      expect(@debug_log).to match(/HTTP Status and Header Data/)
+      expect(@debug_log).not_to match(/HTTP Request Body/)
+      expect(@debug_log).not_to match(/hithere/)
+      expect(@debug_log).to match(/HTTP Response Body/)
+      expect(@debug_log).to match(/Your request is just terrible./)
+    end
+
+    it "Logs the request and response and bodies for 400 POST response" do
+      expect do
+        http_client.post('http://localhost:9000/bad_request', 'hithere')
+      end.to raise_error(Net::HTTPServerException)
+      expect(@debug_log).to match(/400/)
+      expect(@debug_log).to match(/HTTP Request Header Data/)
+      expect(@debug_log).to match(/HTTP Status and Header Data/)
+      expect(@debug_log).to match(/HTTP Request Body/)
+      expect(@debug_log).to match(/hithere/)
+      expect(@debug_log).to match(/HTTP Response Body/)
+      expect(@debug_log).to match(/Your request is just terrible./)
+    end
+  end
+end

data/spec/functional/mixin/shell_out_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Mixin::ShellOut do
           shell_out_with_systems_locale('echo $LC_ALL')
         end
 
-        cmd.stdout.chomp.should match_environment_variable('LC_ALL')
+        expect(cmd.stdout.chomp).to match_environment_variable('LC_ALL')
       end
     end
 
@@ -41,7 +41,7 @@ describe Chef::Mixin::ShellOut do
           shell_out_with_systems_locale('echo $LC_ALL', :environment => {'LC_ALL' => 'POSIX'})
         end
 
-        cmd.stdout.chomp.should eq 'POSIX'
+        expect(cmd.stdout.chomp).to eq 'POSIX'
       end
     end
   end

data/spec/functional/provider/whyrun_safe_ruby_block_spec.rb

@@ -0,0 +1,51 @@
+#
+# Author:: Serdar Sutay (<serdar@opscode.com>)
+# Copyright:: Copyright (c) 2014 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 'spec_helper'
+
+describe Chef::Resource::WhyrunSafeRubyBlock do
+  let(:node) { Chef::Node.new }
+
+  let(:run_context) {
+    events = Chef::EventDispatch::Dispatcher.new
+    Chef::RunContext.new(node, {}, events)
+  }
+
+  before do
+    $evil_global_evil_laugh = :wahwah
+    Chef::Config[:why_run] = true
+  end
+
+  after do
+    Chef::Config[:why_run] = false
+  end
+
+  describe "when testing the resource" do
+    let(:new_resource) do
+      r = Chef::Resource::WhyrunSafeRubyBlock.new("reload all", run_context)
+      r.block { $evil_global_evil_laugh = :mwahahaha }
+      r
+    end
+
+    it "updates the evil laugh, even in why-run mode" do
+      new_resource.run_action(new_resource.action)
+      $evil_global_evil_laugh.should == :mwahahaha
+      new_resource.should be_updated
+    end
+  end
+end

data/spec/functional/rebooter_spec.rb

@@ -0,0 +1,105 @@
+#
+# Author:: Chris Doherty <cdoherty@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef, 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 'spec_helper'
+
+describe Chef::Platform::Rebooter do
+
+  let(:reboot_info) do
+    {
+      :delay_mins => 5,
+      :requested_by => "reboot resource functional test",
+      :reason => "rebooter spec test"
+    }
+  end
+
+  def create_resource
+    resource = Chef::Resource::Reboot.new(expected[:requested_by], run_context)
+    resource.delay_mins(expected[:delay_mins])
+    resource.reason(expected[:reason])
+    resource
+  end
+
+  let(:run_context) do
+    node = Chef::Node.new
+    events = Chef::EventDispatch::Dispatcher.new
+    Chef::RunContext.new(node, {}, events)
+  end
+
+  let(:expected) do
+    {
+      :windows => 'shutdown /r /t 5 /c "rebooter spec test"',
+      :linux => 'shutdown -r +5 "rebooter spec test"'
+    }
+  end
+
+  let(:rebooter) { Chef::Platform::Rebooter }
+
+  describe '#reboot_if_needed!' do
+
+    it 'should not call #shell_out! when reboot has not been requested' do
+      expect(rebooter).to receive(:shell_out!).exactly(0).times
+      expect(rebooter).to receive(:reboot_if_needed!).once.and_call_original
+      rebooter.reboot_if_needed!(run_context.node)
+    end
+
+    describe 'calling #shell_out! to reboot' do
+
+      before(:each) do
+        run_context.request_reboot(reboot_info)
+      end
+
+      after(:each) do
+        run_context.cancel_reboot
+      end
+
+      shared_context 'test a reboot method' do
+        def test_rebooter_method(method_sym, is_windows, expected_reboot_str)
+          Chef::Platform.stub(:windows?).and_return(is_windows)
+          expect(rebooter).to receive(:shell_out!).once.with(expected_reboot_str)
+          expect(rebooter).to receive(method_sym).once.and_call_original
+          rebooter.send(method_sym, run_context.node)
+        end
+      end
+
+      describe 'when using #reboot_if_needed!' do
+        include_context 'test a reboot method'
+
+        it 'should produce the correct string on Windows' do
+          test_rebooter_method(:reboot_if_needed!, true, expected[:windows])
+        end
+
+        it 'should produce the correct (Linux-specific) string on non-Windows' do
+          test_rebooter_method(:reboot_if_needed!, false, expected[:linux])
+        end
+      end
+
+      describe 'when using #reboot!' do
+        include_context 'test a reboot method'
+
+        it 'should produce the correct string on Windows' do
+          test_rebooter_method(:reboot!, true, expected[:windows])
+        end
+
+        it 'should produce the correct (Linux-specific) string on non-Windows' do
+          test_rebooter_method(:reboot!, false, expected[:linux])
+        end
+      end
+    end
+  end
+end