chef 11.2.0 → 11.4.0.rc.0

data/lib/chef/resource.rb

@@ -129,6 +129,23 @@ F
 
     extend Chef::Mixin::ConvertToClassName
 
+    # Track all subclasses of Resource. This is used so names can be looked up
+    # when attempting to deserialize from JSON. (See: json_compat)
+    def self.resource_classes
+      @resource_classes ||= []
+    end
+
+    # Callback when subclass is defined. Adds subclass to list of subclasses.
+    def self.inherited(subclass)
+      resource_classes << subclass
+    end
+
+    # Look up a subclass by +class_name+ which should be a string that matches
+    # `Subclass.name`
+    def self.find_subclass_by_name(class_name)
+      resource_classes.first {|c| c.name == class_name }
+    end
+
     # Set or return the list of "state attributes" implemented by the Resource
     # subclass. State attributes are attributes that describe the desired state
     # of the system, such as file permissions or ownership. In general, state

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '11.2.0'
+  VERSION = '11.4.0.rc.0'
 end
 
 # NOTE: the Chef::Version class is defined in version_class.rb

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

@@ -33,6 +33,7 @@ class Chef
         safe_attach_function :GetCurrentProcess, [], :HANDLE
         safe_attach_function :GetProcessHandleCount, [ :HANDLE, :LPDWORD ], :BOOL
         safe_attach_function :GetProcessId, [ :HANDLE ], :DWORD
+        safe_attach_function :CloseHandle, [ :HANDLE ], :BOOL
 
       end
     end

data/lib/chef/win32/handle.rb

@@ -26,6 +26,10 @@ class Chef
     class Handle
       extend Chef::ReservedNames::Win32::API::Process
 
+      # See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683179(v=vs.85).aspx
+      # The handle value returned by the GetCurrentProcess function is the pseudo handle (HANDLE)-1 (which is 0xFFFFFFFF)
+      CURRENT_PROCESS_HANDLE = 4294967295
+      
       def initialize(handle)
         @handle = handle
         ObjectSpace.define_finalizer(self, Handle.close_handle_finalizer(handle))
@@ -34,7 +38,10 @@ class Chef
       attr_reader :handle
 
       def self.close_handle_finalizer(handle)
-        proc { close_handle(handle) }
+        # According to http://msdn.microsoft.com/en-us/library/windows/desktop/ms683179(v=vs.85).aspx, it is not necessary
+        # to close the pseudo handle returned by the GetCurrentProcess function.  The docs also say that it doesn't hurt to call
+        # CloseHandle on it. However, doing so from inside of Ruby always seems to produce an invalid handle error.
+        proc { close_handle(handle) unless handle == CURRENT_PROCESS_HANDLE }
       end
 
       def self.close_handle(handle)

data/spec/functional/run_lock_spec.rb

@@ -22,6 +22,10 @@ describe Chef::RunLock do
 
   # This behavior is believed to work on windows, but the tests use UNIX APIs.
   describe "when locking the chef-client run", :unix_only => true do
+
+    ##
+    # Lockfile location and helpers
+
     let(:random_temp_root) do
       Kernel.srand(Time.now.to_i + Process.pid)
       "/tmp/#{Kernel.rand(Time.now.to_i + Process.pid)}"
@@ -32,73 +36,183 @@ describe Chef::RunLock do
 
     after(:each){ FileUtils.rm_r(random_temp_root) }
 
+    def wait_on_lock
+      tries = 0
+      until File.exist?(lockfile)
+        raise "Lockfile never created, abandoning test" if tries > 10
+        tries += 1
+        sleep 0.1
+      end
+    end
+
+    ##
+    # Side channel via a pipe allows child processes to send errors to the parent
+
+    # Don't lazy create the pipe or else we might not share it with subprocesses
+    let!(:error_pipe) { IO.pipe }
+    let(:error_read) { error_pipe[0] }
+    let(:error_write) { error_pipe[1] }
+
+    after do
+      error_read.close unless error_read.closed?
+      error_write.close unless error_write.closed?
+    end
+
+    # Send a RuntimeError from the child process to the parent process. Also
+    # prints error to $stdout, just in case something goes wrong with the error
+    # marshaling stuff.
+    def send_side_channel_error(message)
+      $stderr.puts(message)
+      $stderr.puts(caller)
+      e = RuntimeError.new(message)
+      error_write.print(Marshal.dump(e))
+    end
+
+    # Read the error (if any) from the error channel. If a marhaled error is
+    # present, it is unmarshaled and raised (which will fail the test)
+    def raise_side_channel_error!
+      error_write.close
+      err = error_read.read
+      error_read.close
+      begin
+        # ArgumentError from Marshal.load indicates no data, which we assume
+        # means no error in child process.
+        raise Marshal.load(err)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    ##
+    # Interprocess synchronization via a pipe. This allows us to control the
+    # state of the processes competing over the lock without relying on sleep.
+
+    let!(:sync_pipe) { IO.pipe }
+    let(:sync_read) { sync_pipe[0] }
+    let(:sync_write) { sync_pipe[1] }
+
+    after do
+      sync_read.close unless sync_read.closed?
+      sync_write.close unless sync_write.closed?
+    end
+
+    # Wait on synchronization signal. If not received within the timeout, an
+    # error is sent via the error channel, and the process exits.
+    def sync_wait
+      if IO.select([sync_read], nil, nil, 20).nil?
+        # timeout reading from the sync pipe.
+        send_side_channel_error("Error syncing processes in run lock test (timeout)")
+        exit!(1)
+      end
+    end
+
+    # Sends a character in the sync pipe, which wakes ("unlocks") another
+    # process that is waiting on the sync signal
+    def sync_send
+      sync_write.putc("!")
+    end
+
+    ##
+    # IPC to record test results in a pipe. Tests can read pipe contents to
+    # check that operations occur in the expected order.
+
+    let!(:results_pipe) { IO.pipe }
+    let(:results_read) { results_pipe[0] }
+    let(:results_write) { results_pipe[1] }
+
+    after do
+      results_read.close unless results_read.closed?
+      results_write.close unless results_write.closed?
+    end
+
+    # writes the message to the results pipe for later checking.
+    # note that nothing accounts for the pipe filling and waiting forever on a
+    # read or write call, so don't put too much data in.
+    def record(message)
+      results_write.puts(message)
+    end
+
+    def results
+      results_write.close
+      message = results_read.read
+      results_read.close
+      message
+    end
+
+    ##
+    # Run lock is the system under test
+    let!(:run_lock) { Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile) }
+
     it "creates the full path to the lockfile" do
-      run_lock = Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile)
       lambda { run_lock.acquire }.should_not raise_error(Errno::ENOENT)
       File.should exist(lockfile)
     end
 
     it "allows only one chef client run per lockfile" do
-      read, write = IO.pipe
-      run_lock = Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile)
+      # First process, gets the lock and keeps it.
       p1 = fork do
         run_lock.acquire
-        write.puts 1
-        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) running with lock"
+        record "p1 has lock"
+        # Wait until the other process is trying to get the lock:
+        sync_wait
+        # sleep a little bit to make process p2 wait on the lock
         sleep 2
-        write.puts 2
-        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) releasing lock"
+        record "p1 releasing lock"
         run_lock.release
+        exit!(0)
       end
 
-      sleep 0.5
+      # Wait until p1 creates the lockfile
+      wait_on_lock
 
       p2 = fork do
+        # inform process p1 that we're trying to get the lock
+        sync_send
+        record "p2 requesting lock"
         run_lock.acquire
-        write.puts 3
-        #puts "[#{Time.new.to_i % 100}] p2 (#{Process.pid}) running with lock"
+        record "p2 has lock"
         run_lock.release
+        exit!(0)
       end
 
       Process.waitpid2(p1)
       Process.waitpid2(p2)
 
-      write.close
-      order = read.read
-      read.close
+      raise_side_channel_error!
 
-      order.should == "1\n2\n3\n"
+      expected=<<-E
+p1 has lock
+p2 requesting lock
+p1 releasing lock
+p2 has lock
+E
+      results.should == expected
     end
 
     it "clears the lock if the process dies unexpectedly" do
-      read, write = IO.pipe
-      run_lock = Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile)
       p1 = fork do
         run_lock.acquire
-        write.puts 1
-        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) running with lock"
-        sleep 1
-        write.puts 2
-        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) releasing lock"
-        run_lock.release
+        record "p1 has lock"
+        sleep 60
+        record "p1 still has lock"
+        exit! 1
       end
 
+      wait_on_lock
+      Process.kill(:KILL, p1)
+      Process.waitpid2(p1)
+
+
       p2 = fork do
         run_lock.acquire
-        write.puts 3
-        #puts "[#{Time.new.to_i % 100}] p2 (#{Process.pid}) running with lock"
+        record "p2 has lock"
         run_lock.release
+        exit! 0
       end
-      Process.kill(:KILL, p1)
 
-      Process.waitpid2(p1)
       Process.waitpid2(p2)
 
-      write.close
-      order = read.read
-      read.close
-
-      order.should =~ /3\Z/
+      results.should =~ /p2 has lock\Z/
     end
   end
 

data/spec/unit/knife/user_create_spec.rb

@@ -66,7 +66,7 @@ describe Chef::Knife::UserCreate do
 
   it "sets the public key if given" do
     @knife.config[:user_key] = "/a/filename"
-    File.stub(:read).with("/a/filename").and_return("a_key")
+    File.stub(:read).with(File.expand_path("/a/filename")).and_return("a_key")
     @user.should_receive(:public_key).with("a_key")
     @knife.run
   end

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: chef
 version: !ruby/object:Gem::Version 
-  hash: 79
-  prerelease: 
+  hash: 1142537593
+  prerelease: 7
   segments: 
   - 11
-  - 2
+  - 4
   - 0
-  version: 11.2.0
+  - rc
+  - 0
+  version: 11.4.0.rc.0
 platform: ruby
 authors: 
 - Adam Jacob
@@ -15,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-02-06 00:00:00 Z
+date: 2013-02-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: mixlib-config
@@ -149,14 +151,14 @@ dependencies:
         - 4
         - 4
         version: 1.4.4
-    - - ~>
+    - - <=
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 5
         segments: 
         - 1
         - 7
-        - 6
-        version: 1.7.6
+        - 7
+        version: 1.7.7
   type: :runtime
   version_requirements: *id008
 - !ruby/object:Gem::Dependency 
@@ -264,7 +266,7 @@ dependencies:
   type: :development
   version_requirements: *id015
 - !ruby/object:Gem::Dependency 
-  name: ronn
+  name: rake
   prerelease: false
   requirement: &id016 !ruby/object:Gem::Requirement 
     none: false
@@ -278,7 +280,7 @@ dependencies:
   type: :development
   version_requirements: *id016
 - !ruby/object:Gem::Dependency 
-  name: rake
+  name: rack
   prerelease: false
   requirement: &id017 !ruby/object:Gem::Requirement 
     none: false
@@ -292,7 +294,7 @@ dependencies:
   type: :development
   version_requirements: *id017
 - !ruby/object:Gem::Dependency 
-  name: rack
+  name: rspec_junit_formatter
   prerelease: false
   requirement: &id018 !ruby/object:Gem::Requirement 
     none: false
@@ -305,24 +307,10 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id018
-- !ruby/object:Gem::Dependency 
-  name: rspec_junit_formatter
-  prerelease: false
-  requirement: &id019 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id019
 - !ruby/object:Gem::Dependency 
   name: rspec-core
   prerelease: false
-  requirement: &id020 !ruby/object:Gem::Requirement 
+  requirement: &id019 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -334,11 +322,11 @@ dependencies:
         - 0
         version: 2.12.0
   type: :development
-  version_requirements: *id020
+  version_requirements: *id019
 - !ruby/object:Gem::Dependency 
   name: rspec-expectations
   prerelease: false
-  requirement: &id021 !ruby/object:Gem::Requirement 
+  requirement: &id020 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -350,11 +338,11 @@ dependencies:
         - 0
         version: 2.12.0
   type: :development
-  version_requirements: *id021
+  version_requirements: *id020
 - !ruby/object:Gem::Dependency 
   name: rspec-mocks
   prerelease: false
-  requirement: &id022 !ruby/object:Gem::Requirement 
+  requirement: &id021 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -366,7 +354,7 @@ dependencies:
         - 0
         version: 2.12.0
   type: :development
-  version_requirements: *id022
+  version_requirements: *id021
 description: A systems integration framework, built to bring the benefits of configuration management to your entire infrastructure.
 email: adam@opscode.com
 executables: 
@@ -1478,12 +1466,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: