chef 11.14.0.alpha.3-x86-mingw32 → 11.14.0.alpha.4-x86-mingw32

data/lib/chef/util/path_helper.rb

@@ -0,0 +1,94 @@
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# 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/platform'
+require 'chef/exceptions'
+
+class Chef
+  class Util
+    class PathHelper
+      # Maximum characters in a standard Windows path (260 including drive letter and NUL)
+      WIN_MAX_PATH = 259
+
+      def self.validate_path(path)
+        if Chef::Platform.windows?
+          unless printable?(path)
+            msg = "Path '#{path}' contains non-printable characters. Check that backslashes are escaped with another backslash (e.g. C:\\\\Windows) in double-quoted strings."
+            Chef::Log.error(msg)
+            raise Chef::Exceptions::ValidationFailed, msg
+          end
+            
+          if windows_max_length_exceeded?(path)
+            Chef::Log.debug("Path '#{path}' is longer than #{WIN_MAX_PATH}, prefixing with'\\\\?\\'")
+            path.insert(0, "\\\\?\\")
+          end
+        end
+
+        path
+      end
+
+      def self.windows_max_length_exceeded?(path)
+        # Check to see if paths without the \\?\ prefix are over the maximum allowed length for the Windows API
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx
+        unless path =~ /^\\\\?\\/
+          if path.length > WIN_MAX_PATH
+            return true
+          end
+        end
+        
+        false
+      end
+
+      def self.printable?(string)
+        # returns true if string is free of non-printable characters (escape sequences)
+        # this returns false for whitespace escape sequences as well, e.g. \n\t
+        if string =~ /[^[:print:]]/
+          false
+        else
+          true
+        end
+      end
+
+      # Produces a comparable path.
+      def self.canonical_path(path, add_prefix=true)
+        # Rather than find an equivalent for File.absolute_path on 1.8.7, just bail out
+        raise NotImplementedError, "This feature is not supported on Ruby versions < 1.9" if RUBY_VERSION.to_f < 1.9
+
+        # First remove extra separators and resolve any relative paths
+        abs_path = File.absolute_path(path)
+
+        if Chef::Platform.windows?
+          # Add the \\?\ API prefix on Windows unless add_prefix is false
+          # Downcase on Windows where paths are still case-insensitive
+          abs_path.gsub!(::File::SEPARATOR, ::File::ALT_SEPARATOR)
+          if add_prefix && abs_path !~ /^\\\\?\\/
+            abs_path.insert(0, "\\\\?\\")
+          end
+
+          abs_path.downcase!
+        end
+
+        abs_path
+      end
+
+      def self.paths_eql?(path1, path2)
+        canonical_path(path1) == canonical_path(path2)
+      end
+    end
+  end
+end

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '11.14.0.alpha.3'
+  VERSION = '11.14.0.alpha.4'
 end
 
 # NOTE: the Chef::Version class is defined in version_class.rb

data/spec/functional/application_spec.rb

@@ -0,0 +1,58 @@
+#
+# 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 'spec_helper'
+require 'chef/mixin/shell_out'
+
+describe Chef::Application do
+  include Chef::Mixin::ShellOut
+
+  before do
+    @original_argv = ARGV.dup
+    ARGV.clear
+    @original_env = ENV.to_hash
+    ENV.clear
+    @app = Chef::Application.new
+  end
+
+  after do
+    ARGV.replace(@original_argv)
+    ENV.clear
+    ENV.update(@original_env)
+  end
+
+  describe "when proxy options are set in config" do
+    before do
+      Chef::Config[:http_proxy] = "http://proxy.example.org:8080"
+      Chef::Config[:https_proxy] = nil
+      Chef::Config[:ftp_proxy] = nil
+      Chef::Config[:no_proxy] = nil
+
+      @app.configure_proxy_environment_variables
+    end
+
+    it "saves built proxy to ENV which shell_out can use" do
+      so = if windows?
+        shell_out("echo $env:http_proxy")
+      else
+        shell_out("echo $http_proxy")
+      end
+
+      so.stdout.should == "http://proxy.example.org:8080\n"
+    end
+  end
+end

data/spec/functional/resource/mount_spec.rb

@@ -21,7 +21,7 @@ require 'chef/mixin/shell_out'
 require 'tmpdir'
 
 # run this test only for following platforms.
-include_flag = !(['ubuntu', 'centos', 'aix'].include?(ohai[:platform]))
+include_flag = !(['ubuntu', 'centos', 'aix', 'solaris2'].include?(ohai[:platform]))
 
 describe Chef::Resource::Mount, :requires_root, :external => include_flag do
 
@@ -52,6 +52,9 @@ describe Chef::Resource::Mount, :requires_root, :external => include_flag do
       end
       fstype = "tmpfs"
       shell_out!("mkfs -q #{device} 512")
+    when "solaris2"
+      device = "swap"
+      fstype = "tmpfs"
     else
     end
     [device, fstype]
@@ -71,11 +74,10 @@ describe Chef::Resource::Mount, :requires_root, :external => include_flag do
   end
 
   # platform specific validations.
-  def mount_should_exists(mount_point, device, fstype = nil, options = nil)
+  def mount_should_exist(mount_point, device, fstype = nil, options = nil)
     validation_cmd = "mount | grep #{mount_point} | grep #{device} "
     validation_cmd << " | grep #{fstype} " unless fstype.nil?
     validation_cmd << " | grep #{options.join(',')} " unless options.nil? || options.empty?
-    puts "validation_cmd = #{validation_cmd}"
     expect(shell_out(validation_cmd).exitstatus).to eq(0)
   end
 
@@ -87,6 +89,8 @@ describe Chef::Resource::Mount, :requires_root, :external => include_flag do
     case ohai[:platform]
     when 'aix'
       mount_config = "/etc/filesystems"
+    when 'solaris2'
+      mount_config = "/etc/vfstab"
     else
       mount_config = "/etc/fstab"
     end
@@ -119,7 +123,7 @@ describe Chef::Resource::Mount, :requires_root, :external => include_flag do
     provider
   end
 
-  def current_resource
+  let(:current_resource) do
     provider.load_current_resource
     provider.current_resource
   end
@@ -138,7 +142,6 @@ describe Chef::Resource::Mount, :requires_root, :external => include_flag do
         end
       end
     end
-
   end
 
   after(:all) do
@@ -156,28 +159,28 @@ describe Chef::Resource::Mount, :requires_root, :external => include_flag do
       current_resource.mounted.should be_false
       new_resource.run_action(:mount)
       new_resource.should be_updated
-      mount_should_exists(new_resource.mount_point, new_resource.device)
+      mount_should_exist(new_resource.mount_point, new_resource.device)
     end
-
   end
 
-  describe "when the filesystem should be remounted and the resource supports remounting" do
+  # don't run the remount tests on solaris2 (tmpfs does not support remount)
+  describe "when the filesystem should be remounted and the resource supports remounting", :external => ohai[:platform] == "solaris2" do
     it "should remount the filesystem if it is mounted" do
       new_resource.run_action(:mount)
-      mount_should_exists(new_resource.mount_point, new_resource.device)
+      mount_should_exist(new_resource.mount_point, new_resource.device)
 
       new_resource.supports[:remount] = true
       new_resource.options "rw,log=NULL" if ohai[:platform] == 'aix'
       new_resource.run_action(:remount)
 
-      mount_should_exists(new_resource.mount_point, new_resource.device, nil, (ohai[:platform] == 'aix') ? new_resource.options : nil)
+      mount_should_exist(new_resource.mount_point, new_resource.device, nil, (ohai[:platform] == 'aix') ? new_resource.options : nil)
     end
   end
 
   describe "when the target state is a unmounted filesystem" do
     it "should umount the filesystem if it is mounted" do
       new_resource.run_action(:mount)
-      mount_should_exists(new_resource.mount_point, new_resource.device)
+      mount_should_exist(new_resource.mount_point, new_resource.device)
 
       new_resource.run_action(:umount)
       mount_should_not_exists(new_resource.mount_point)

data/spec/integration/client/client_spec.rb

@@ -206,6 +206,17 @@ EOM
       result.error!
     end
 
+    it "should not print SSL warnings when running in local-mode" do
+      file 'config/client.rb', <<EOM
+chef_server_url 'http://omg.com/blah'
+cookbook_path "#{path_to('cookbooks')}"
+EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --local-mode", :cwd => chef_dir)
+      result.stdout.should_not include("SSL validation of HTTPS requests is disabled.")
+      result.error!
+    end
+
     it "should complete with success when passed -z and --chef-zero-port" do
       file 'config/client.rb', <<EOM
 chef_server_url 'http://omg.com/blah'

data/spec/integration/knife/common_options_spec.rb

@@ -50,6 +50,15 @@ describe 'knife common options' do
         end
       end
 
+      context 'And chef_zero.host is 0.0.0.0' do
+        before(:each) { Chef::Config.chef_zero.host = '0.0.0.0' }
+ 
+        it 'knife raw /nodes/x should retrieve the role' do
+          knife('raw /nodes/x').should_succeed /"name": "x"/
+          Chef::Config.chef_server_url.should == 'http://0.0.0.0:8889'
+        end
+      end
+
       context 'and there is a private key' do
         file 'mykey.pem', <<EOM
 -----BEGIN RSA PRIVATE KEY-----

data/spec/unit/application_spec.rb

@@ -39,6 +39,7 @@ describe Chef::Application do
       @app = Chef::Application.new
       @app.stub(:configure_chef).and_return(true)
       @app.stub(:configure_logging).and_return(true)
+      @app.stub(:configure_proxy_environment_variables).and_return(true)
     end
 
     it "should configure chef" do
@@ -51,6 +52,10 @@ describe Chef::Application do
       @app.reconfigure
     end
 
+    it "should configure environment variables" do
+      @app.should_receive(:configure_proxy_environment_variables).and_return(true)
+      @app.reconfigure
+    end
   end
 
   describe Chef::Application do
@@ -235,6 +240,158 @@ describe Chef::Application do
     end
   end
 
+  describe "when configuring environment variables" do
+    def configure_proxy_environment_variables_stubs
+      @app.stub(:configure_http_proxy).and_return(true)
+      @app.stub(:configure_https_proxy).and_return(true)
+      @app.stub(:configure_ftp_proxy).and_return(true)
+      @app.stub(:configure_no_proxy).and_return(true)
+    end
+
+    shared_examples_for "setting ENV['http_proxy']" do
+      before do
+        Chef::Config[:http_proxy] = http_proxy
+      end
+
+      it "should set ENV['http_proxy']" do
+        @app.configure_proxy_environment_variables
+        @env['http_proxy'].should == "http://#{address}:#{port}"
+      end
+
+      describe "when Chef::Config[:http_proxy_user] is set" do
+        before do
+          Chef::Config[:http_proxy_user] = "username"
+        end
+
+        it "should set ENV['http_proxy'] with the username" do
+          @app.configure_proxy_environment_variables
+          @env['http_proxy'].should == "http://username@#{address}:#{port}"
+        end
+
+        context "when :http_proxy_user contains '@' and/or ':'" do
+          before do
+            Chef::Config[:http_proxy_user] = "my:usern@me"
+          end
+
+          it "should set ENV['http_proxy'] with the escaped username" do
+            @app.configure_proxy_environment_variables
+            @env['http_proxy'].should == "http://my%3Ausern%40me@#{address}:#{port}"
+          end
+        end
+
+        describe "when Chef::Config[:http_proxy_pass] is set" do
+          before do
+            Chef::Config[:http_proxy_pass] = "password"
+          end
+
+          it "should set ENV['http_proxy'] with the password" do
+            @app.configure_proxy_environment_variables
+            @env['http_proxy'].should == "http://username:password@#{address}:#{port}"
+          end
+
+          context "when :http_proxy_pass contains '@' and/or ':'" do
+            before do
+              Chef::Config[:http_proxy_pass] = ":P@ssword101"
+            end
+
+            it "should set ENV['http_proxy'] with the escaped password" do
+              @app.configure_proxy_environment_variables
+              @env['http_proxy'].should == "http://username:%3AP%40ssword101@#{address}:#{port}"
+            end
+          end
+        end
+      end
+
+      describe "when Chef::Config[:http_proxy_pass] is set (but not Chef::Config[:http_proxy_user])" do
+        before do
+          Chef::Config[:http_proxy_user] = nil
+          Chef::Config[:http_proxy_pass] = "password"
+        end
+
+        it "should set ENV['http_proxy']" do
+          @app.configure_proxy_environment_variables
+          @env['http_proxy'].should == "http://#{address}:#{port}"
+        end
+      end
+    end
+
+    describe "when configuring ENV['http_proxy']" do
+      before do
+        @env = {}
+        @app.stub(:env).and_return(@env)
+
+        @app.stub(:configure_https_proxy).and_return(true)
+        @app.stub(:configure_ftp_proxy).and_return(true)
+        @app.stub(:configure_no_proxy).and_return(true)
+      end
+
+      describe "when Chef::Config[:http_proxy] is not set" do
+        before do
+          Chef::Config[:http_proxy] = nil
+        end
+
+        it "should not set ENV['http_proxy']" do
+          @app.configure_proxy_environment_variables
+          @env.should == {}
+        end
+      end
+
+      describe "when Chef::Config[:http_proxy] is set" do
+        context "when given an FQDN" do
+          let(:address) { "proxy.example.org" }
+          let(:port) { 8080 }
+          let(:http_proxy) { "http://#{address}:#{port}" }
+
+          it_should_behave_like "setting ENV['http_proxy']"
+        end
+
+        context "when given an IP" do
+          let(:address) { "127.0.0.1" }
+          let(:port) { 22 }
+          let(:http_proxy) { "http://#{address}:#{port}" }
+
+          it_should_behave_like "setting ENV['http_proxy']"
+        end
+
+        context "when given an IPv6" do
+          let(:address) { "[2001:db8::1]" }
+          let(:port) { 80 }
+          let(:http_proxy) { "http://#{address}:#{port}" }
+
+          it_should_behave_like "setting ENV['http_proxy']"
+        end
+
+        context "when given without including http://" do
+          let(:address) { "proxy.example.org" }
+          let(:port) { 8181 }
+          let(:http_proxy) { "#{address}:#{port}" }
+
+          it_should_behave_like "setting ENV['http_proxy']"
+        end
+
+        context "when given the full proxy in :http_proxy only" do
+          before do
+            Chef::Config[:http_proxy] = "http://username:password@proxy.example.org:2222"
+            Chef::Config[:http_proxy_user] = nil
+            Chef::Config[:http_proxy_pass] = nil
+          end
+
+          it "should set ENV['http_proxy']" do
+            @app.configure_proxy_environment_variables
+            @env['http_proxy'].should == Chef::Config[:http_proxy]
+          end
+        end
+
+        context "when the config options aren't URI compliant" do
+          it "raises Chef::Exceptions::BadProxyURI" do
+            Chef::Config[:http_proxy] = "http://proxy.bad_example.org/:8080"
+            expect { @app.configure_proxy_environment_variables }.to raise_error(Chef::Exceptions::BadProxyURI)
+          end
+        end
+      end
+    end
+  end
+
   describe "class method: fatal!" do
     before do
       STDERR.stub(:puts).with("FATAL: blah").and_return(true)