chef 14.15.6-universal-mingw32 → 15.0.293-universal-mingw32

data/lib/chef/run_list/run_list_item.rb

@@ -1,98 +1,98 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2010-2016, 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.
-
-class Chef
-  class RunList
-    class RunListItem
-      QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}
-      QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}
-      VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}
-      FALSE_FRIEND                 = %r{[\[\]]}
-
-      attr_reader :name, :type, :version
-
-      def initialize(item)
-        @version = nil
-        case item
-        when Hash
-          assert_hash_is_valid_run_list_item!(item)
-          @type = (item["type"] || item[:type]).to_sym
-          @name = item["name"] || item[:name]
-          if item.key?("version") || item.key?(:version)
-            @version = item["version"] || item[:version]
-          end
-        when String
-          if match = QUALIFIED_RECIPE.match(item)
-            # recipe[recipe_name]
-            # recipe[recipe_name@1.0.0]
-            @type = :recipe
-            @name = match[1]
-            @version = match[3] if match[3]
-          elsif match = QUALIFIED_ROLE.match(item)
-            # role[role_name]
-            @type = :role
-            @name = match[1]
-          elsif match = VERSIONED_UNQUALIFIED_RECIPE.match(item)
-            # recipe_name@1.0.0
-            @type = :recipe
-            @name = match[1]
-            @version = match[3] if match[3]
-          elsif match = FALSE_FRIEND.match(item)
-            # Recipe[recipe_name]
-            # roles[role_name]
-            name = match[1]
-            raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be recipe[#{name}] or role[#{name}]"
-
-          else
-            # recipe_name
-            @type = :recipe
-            @name = item
-          end
-        else
-          raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be a Hash or String"
-        end
-      end
-
-      def to_s
-        "#{@type}[#{@name}#{@version ? "@#{@version}" : ""}]"
-      end
-
-      def role?
-        @type == :role
-      end
-
-      def recipe?
-        @type == :recipe
-      end
-
-      def ==(other)
-        if other.kind_of?(String)
-          to_s == other.to_s
-        else
-          other.respond_to?(:type) && other.respond_to?(:name) && other.respond_to?(:version) && other.type == @type && other.name == @name && other.version == @version
-        end
-      end
-
-      def assert_hash_is_valid_run_list_item!(item)
-        unless (item.key?("type") || item.key?(:type)) && (item.key?("name") || item.key?(:name))
-          raise ArgumentError, "Initializing a #{self.class} from a hash requires that it have a 'type' and 'name' key"
-        end
-      end
-
-    end
-  end
-end
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2010-2016, 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.
+
+class Chef
+  class RunList
+    class RunListItem
+      QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}.freeze
+      QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}.freeze
+      VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}.freeze
+      FALSE_FRIEND                 = %r{[\[\]]}.freeze
+
+      attr_reader :name, :type, :version
+
+      def initialize(item)
+        @version = nil
+        case item
+        when Hash
+          assert_hash_is_valid_run_list_item!(item)
+          @type = (item["type"] || item[:type]).to_sym
+          @name = item["name"] || item[:name]
+          if item.key?("version") || item.key?(:version)
+            @version = item["version"] || item[:version]
+          end
+        when String
+          if match = QUALIFIED_RECIPE.match(item)
+            # recipe[recipe_name]
+            # recipe[recipe_name@1.0.0]
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          elsif match = QUALIFIED_ROLE.match(item)
+            # role[role_name]
+            @type = :role
+            @name = match[1]
+          elsif match = VERSIONED_UNQUALIFIED_RECIPE.match(item)
+            # recipe_name@1.0.0
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          elsif match = FALSE_FRIEND.match(item)
+            # Recipe[recipe_name]
+            # roles[role_name]
+            name = match[1]
+            raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be recipe[#{name}] or role[#{name}]"
+
+          else
+            # recipe_name
+            @type = :recipe
+            @name = item
+          end
+        else
+          raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be a Hash or String"
+        end
+      end
+
+      def to_s
+        "#{@type}[#{@name}#{@version ? "@#{@version}" : ""}]"
+      end
+
+      def role?
+        @type == :role
+      end
+
+      def recipe?
+        @type == :recipe
+      end
+
+      def ==(other)
+        if other.kind_of?(String)
+          to_s == other.to_s
+        else
+          other.respond_to?(:type) && other.respond_to?(:name) && other.respond_to?(:version) && other.type == @type && other.name == @name && other.version == @version
+        end
+      end
+
+      def assert_hash_is_valid_run_list_item!(item)
+        unless (item.key?("type") || item.key?(:type)) && (item.key?("name") || item.key?(:name))
+          raise ArgumentError, "Initializing a #{self.class} from a hash requires that it have a 'type' and 'name' key"
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -1,104 +1,104 @@
-#
-# Author:: Stephen Delano (<stephen@chef.io>)
-# Author:: Seth Falcon (<seth@chef.io>)
-# Copyright:: Copyright 2010-2017, 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"
-require "chef/version_constraint"
-
-# Why does this class exist?
-# Why did we not just modify RunList/RunListItem?
-class Chef
-  class RunList
-    class VersionedRecipeList < Array
-
-      def initialize
-        super
-        @versions = Hash.new
-      end
-
-      def add_recipe(name, version = nil)
-        if version && @versions.key?(name)
-          unless Chef::Version.new(@versions[name]) == Chef::Version.new(version)
-            raise Chef::Exceptions::CookbookVersionConflict, "Run list requires #{name} at versions #{@versions[name]} and #{version}"
-          end
-        end
-        @versions[name] = version if version
-        self << name unless include?(name)
-      end
-
-      def with_versions
-        map { |recipe_name| { name: recipe_name, version: @versions[recipe_name] } }
-      end
-
-      # Return an Array of Hashes, each of the form:
-      #  {:name => RECIPE_NAME, :version_constraint => Chef::VersionConstraint }
-      def with_version_constraints
-        map do |recipe_name|
-          constraint = Chef::VersionConstraint.new(@versions[recipe_name])
-          { name: recipe_name, version_constraint: constraint }
-        end
-      end
-
-      # Return an Array of Strings, each of the form:
-      #  "NAME@VERSION"
-      def with_version_constraints_strings
-        map do |recipe_name|
-          if @versions[recipe_name]
-            "#{recipe_name}@#{@versions[recipe_name]}"
-          else
-            recipe_name
-          end
-        end
-      end
-
-      # Get an array of strings of the fully-qualified recipe names (with ::default appended) and
-      # with the versions in "NAME@VERSION" format.
-      #
-      # @return [Array] Array of strings with fully-qualified recipe names
-      def with_fully_qualified_names_and_version_constraints
-        map do |recipe_name|
-          qualified_recipe = if recipe_name.include?("::")
-                               recipe_name
-                             else
-                               "#{recipe_name}::default"
-                             end
-
-          version = @versions[recipe_name]
-          qualified_recipe = "#{qualified_recipe}@#{version}" if version
-
-          qualified_recipe
-        end
-      end
-
-      # For "foo::default" also include "foo", for "foo" also include "foo::default", for
-      # "foo::bar" just return "foo::bar".  This makes it easier for people to search on
-      # default recipe names.
-      #
-      # @return [Array] Array of strings with fully-qualified and unexpanded recipe names
-      def with_duplicate_names
-        map do |recipe_name|
-          if recipe_name.end_with?("::default")
-            [ recipe_name.sub(/::default$/, ""), recipe_name ]
-          elsif recipe_name.include?("::")
-            recipe_name
-          else
-            [ recipe_name, "#{recipe_name}::default" ]
-          end
-        end.flatten
-      end
-    end
-  end
-end
+#
+# Author:: Stephen Delano (<stephen@chef.io>)
+# Author:: Seth Falcon (<seth@chef.io>)
+# Copyright:: Copyright 2010-2017, 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_relative "../version_class"
+require_relative "../version_constraint"
+
+# Why does this class exist?
+# Why did we not just modify RunList/RunListItem?
+class Chef
+  class RunList
+    class VersionedRecipeList < Array
+
+      def initialize
+        super
+        @versions = Hash.new
+      end
+
+      def add_recipe(name, version = nil)
+        if version && @versions.key?(name)
+          unless Chef::Version.new(@versions[name]) == Chef::Version.new(version)
+            raise Chef::Exceptions::CookbookVersionConflict, "Run list requires #{name} at versions #{@versions[name]} and #{version}"
+          end
+        end
+        @versions[name] = version if version
+        self << name unless include?(name)
+      end
+
+      def with_versions
+        map { |recipe_name| { name: recipe_name, version: @versions[recipe_name] } }
+      end
+
+      # Return an Array of Hashes, each of the form:
+      #  {:name => RECIPE_NAME, :version_constraint => Chef::VersionConstraint }
+      def with_version_constraints
+        map do |recipe_name|
+          constraint = Chef::VersionConstraint.new(@versions[recipe_name])
+          { name: recipe_name, version_constraint: constraint }
+        end
+      end
+
+      # Return an Array of Strings, each of the form:
+      #  "NAME@VERSION"
+      def with_version_constraints_strings
+        map do |recipe_name|
+          if @versions[recipe_name]
+            "#{recipe_name}@#{@versions[recipe_name]}"
+          else
+            recipe_name
+          end
+        end
+      end
+
+      # Get an array of strings of the fully-qualified recipe names (with ::default appended) and
+      # with the versions in "NAME@VERSION" format.
+      #
+      # @return [Array] Array of strings with fully-qualified recipe names
+      def with_fully_qualified_names_and_version_constraints
+        map do |recipe_name|
+          qualified_recipe = if recipe_name.include?("::")
+                               recipe_name
+                             else
+                               "#{recipe_name}::default"
+                             end
+
+          version = @versions[recipe_name]
+          qualified_recipe = "#{qualified_recipe}@#{version}" if version
+
+          qualified_recipe
+        end
+      end
+
+      # For "foo::default" also include "foo", for "foo" also include "foo::default", for
+      # "foo::bar" just return "foo::bar".  This makes it easier for people to search on
+      # default recipe names.
+      #
+      # @return [Array] Array of strings with fully-qualified and unexpanded recipe names
+      def with_duplicate_names
+        map do |recipe_name|
+          if recipe_name.end_with?("::default")
+            [ recipe_name.sub(/::default$/, ""), recipe_name ]
+          elsif recipe_name.include?("::")
+            recipe_name
+          else
+            [ recipe_name, "#{recipe_name}::default" ]
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/lib/chef/run_lock.rb

@@ -1,197 +1,198 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2012-2016, 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/mixin/create_path"
-require "fcntl"
-if Chef::Platform.windows?
-  require "chef/win32/mutex"
-end
-require "chef/config"
-require "chef/exceptions"
-require "timeout"
-
-class Chef
-
-  # == Chef::RunLock
-  # Provides an interface for acquiring and releasing a system-wide exclusive
-  # lock.
-  #
-  # Used by Chef::Client to ensure only one instance of chef-client (or solo)
-  # is modifying the system at a time.
-  class RunLock
-    include Chef::Mixin::CreatePath
-
-    attr_reader :runlock
-    attr_reader :mutex
-    attr_reader :runlock_file
-
-    # Create a new instance of RunLock
-    # === Arguments
-    # * :lockfile::: the full path to the lockfile.
-    def initialize(lockfile)
-      @runlock_file = lockfile
-      @runlock = nil
-      @mutex = nil
-      @runpid = nil
-    end
-
-    # Acquire the system-wide lock. Will block indefinitely if another process
-    # already has the lock and Chef::Config[:run_lock_timeout] is
-    # not set. Otherwise will block for Chef::Config[:run_lock_timeout]
-    # seconds and exit if the lock is not acquired.
-    #
-    # Each call to acquire should have a corresponding call to #release.
-    #
-    # The implementation is based on File#flock (see also: flock(2)).
-    #
-    # Either acquire() or test() methods should be called in order to
-    # get the ownership of run_lock.
-    def acquire
-      if timeout_given?
-        begin
-          Timeout.timeout(time_to_wait) do
-            unless test
-              if time_to_wait > 0.0
-                wait
-              else
-                exit_from_timeout
-              end
-            end
-          end
-        rescue Timeout::Error
-          exit_from_timeout
-        end
-      else
-        wait unless test
-      end
-    end
-
-    #
-    # Tests and if successful acquires the system-wide lock.
-    # Returns true if the lock is acquired, false otherwise.
-    #
-    # Either acquire() or test() methods should be called in order to
-    # get the ownership of run_lock.
-    def test
-      create_lock
-      acquire_lock
-    end
-
-    #
-    # Waits until acquiring the system-wide lock.
-    #
-    def wait
-      Chef::Log.warn("Chef client #{runpid} is running, will wait for it to finish and then run.")
-      if Chef::Platform.windows?
-        mutex.wait
-      else
-        runlock.flock(File::LOCK_EX)
-      end
-    end
-
-    def save_pid
-      runlock.truncate(0)
-      runlock.rewind # truncate doesn't reset position to 0.
-      runlock.write(Process.pid.to_s)
-      # flush the file fsync flushes the system buffers
-      # in addition to ruby buffers
-      runlock.fsync
-    end
-
-    # Release the system-wide lock.
-    def release
-      if runlock
-        if Chef::Platform.windows?
-          mutex.release
-        else
-          runlock.flock(File::LOCK_UN)
-        end
-        runlock.close
-        # Don't unlink the pid file, if another chef-client was waiting, it
-        # won't be recreated. Better to leave a "dead" pid file than not have
-        # it available if you need to break the lock.
-        reset
-      end
-    end
-
-    # @api private solely for race condition tests
-    def create_lock
-      # ensure the runlock_file path exists
-      create_path(File.dirname(runlock_file))
-      @runlock = File.open(runlock_file, "a+")
-    end
-
-    # @api private solely for race condition tests
-    def acquire_lock
-      if Chef::Platform.windows?
-        acquire_win32_mutex
-      else
-        # If we support FD_CLOEXEC, then use it.
-        # NB: ruby-2.0.0-p195 sets FD_CLOEXEC by default, but not
-        # ruby-1.8.7/1.9.3
-        if Fcntl.const_defined?("F_SETFD") && Fcntl.const_defined?("FD_CLOEXEC")
-          runlock.fcntl(Fcntl::F_SETFD, runlock.fcntl(Fcntl::F_GETFD, 0) | Fcntl::FD_CLOEXEC)
-        end
-        # Flock will return 0 if it can acquire the lock otherwise it
-        # will return false
-        if runlock.flock(File::LOCK_NB | File::LOCK_EX) == 0
-          true
-        else
-          false
-        end
-      end
-    end
-
-    private
-
-    def reset
-      @runlock = nil
-      @mutex = nil
-      @runpid = nil
-    end
-
-    # Since flock mechanism doesn't exist on windows we are using
-    # platform Mutex.
-    # We are creating a "Global" mutex here so that non-admin
-    # users can not DoS chef-client by creating the same named
-    # mutex we are using locally.
-    # Mutex name is case-sensitive contrary to other things in
-    # windows. "\" is the only invalid character.
-    def acquire_win32_mutex
-      @mutex = Chef::ReservedNames::Win32::Mutex.new("Global\\#{runlock_file.gsub(/[\\]/, "/").downcase}")
-      mutex.test
-    end
-
-    def runpid
-      @runpid ||= runlock.read.strip
-    end
-
-    def timeout_given?
-      !time_to_wait.nil?
-    end
-
-    def time_to_wait
-      Chef::Config[:run_lock_timeout]
-    end
-
-    def exit_from_timeout
-      rp = runpid
-      release # Just to be on the safe side...
-      raise Chef::Exceptions::RunLockTimeout.new(time_to_wait, rp)
-    end
-  end
-end
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2012-2016, 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_relative "mixin/create_path"
+require "fcntl"
+if Chef::Platform.windows?
+  require_relative "win32/mutex"
+end
+require_relative "config"
+require_relative "exceptions"
+require "timeout"
+require_relative "dist"
+
+class Chef
+
+  # == Chef::RunLock
+  # Provides an interface for acquiring and releasing a system-wide exclusive
+  # lock.
+  #
+  # Used by Chef::Client to ensure only one instance of chef-client (or solo)
+  # is modifying the system at a time.
+  class RunLock
+    include Chef::Mixin::CreatePath
+
+    attr_reader :runlock
+    attr_reader :mutex
+    attr_reader :runlock_file
+
+    # Create a new instance of RunLock
+    # === Arguments
+    # * :lockfile::: the full path to the lockfile.
+    def initialize(lockfile)
+      @runlock_file = lockfile
+      @runlock = nil
+      @mutex = nil
+      @runpid = nil
+    end
+
+    # Acquire the system-wide lock. Will block indefinitely if another process
+    # already has the lock and Chef::Config[:run_lock_timeout] is
+    # not set. Otherwise will block for Chef::Config[:run_lock_timeout]
+    # seconds and exit if the lock is not acquired.
+    #
+    # Each call to acquire should have a corresponding call to #release.
+    #
+    # The implementation is based on File#flock (see also: flock(2)).
+    #
+    # Either acquire() or test() methods should be called in order to
+    # get the ownership of run_lock.
+    def acquire
+      if timeout_given?
+        begin
+          Timeout.timeout(time_to_wait) do
+            unless test
+              if time_to_wait > 0.0
+                wait
+              else
+                exit_from_timeout
+              end
+            end
+          end
+        rescue Timeout::Error
+          exit_from_timeout
+        end
+      else
+        wait unless test
+      end
+    end
+
+    #
+    # Tests and if successful acquires the system-wide lock.
+    # Returns true if the lock is acquired, false otherwise.
+    #
+    # Either acquire() or test() methods should be called in order to
+    # get the ownership of run_lock.
+    def test
+      create_lock
+      acquire_lock
+    end
+
+    #
+    # Waits until acquiring the system-wide lock.
+    #
+    def wait
+      Chef::Log.warn("#{Chef::Dist::PRODUCT} #{runpid} is running, will wait for it to finish and then run.")
+      if Chef::Platform.windows?
+        mutex.wait
+      else
+        runlock.flock(File::LOCK_EX)
+      end
+    end
+
+    def save_pid
+      runlock.truncate(0)
+      runlock.rewind # truncate doesn't reset position to 0.
+      runlock.write(Process.pid.to_s)
+      # flush the file fsync flushes the system buffers
+      # in addition to ruby buffers
+      runlock.fsync
+    end
+
+    # Release the system-wide lock.
+    def release
+      if runlock
+        if Chef::Platform.windows?
+          mutex.release
+        else
+          runlock.flock(File::LOCK_UN)
+        end
+        runlock.close
+        # Don't unlink the pid file, if another chef-client was waiting, it
+        # won't be recreated. Better to leave a "dead" pid file than not have
+        # it available if you need to break the lock.
+        reset
+      end
+    end
+
+    # @api private solely for race condition tests
+    def create_lock
+      # ensure the runlock_file path exists
+      create_path(File.dirname(runlock_file))
+      @runlock = File.open(runlock_file, "a+")
+    end
+
+    # @api private solely for race condition tests
+    def acquire_lock
+      if Chef::Platform.windows?
+        acquire_win32_mutex
+      else
+        # If we support FD_CLOEXEC, then use it.
+        # NB: ruby-2.0.0-p195 sets FD_CLOEXEC by default, but not
+        # ruby-1.8.7/1.9.3
+        if Fcntl.const_defined?("F_SETFD") && Fcntl.const_defined?("FD_CLOEXEC")
+          runlock.fcntl(Fcntl::F_SETFD, runlock.fcntl(Fcntl::F_GETFD, 0) | Fcntl::FD_CLOEXEC)
+        end
+        # Flock will return 0 if it can acquire the lock otherwise it
+        # will return false
+        if runlock.flock(File::LOCK_NB | File::LOCK_EX) == 0
+          true
+        else
+          false
+        end
+      end
+    end
+
+    private
+
+    def reset
+      @runlock = nil
+      @mutex = nil
+      @runpid = nil
+    end
+
+    # Since flock mechanism doesn't exist on windows we are using
+    # platform Mutex.
+    # We are creating a "Global" mutex here so that non-admin
+    # users can not DoS chef-client by creating the same named
+    # mutex we are using locally.
+    # Mutex name is case-sensitive contrary to other things in
+    # windows. "\" is the only invalid character.
+    def acquire_win32_mutex
+      @mutex = Chef::ReservedNames::Win32::Mutex.new("Global\\#{runlock_file.gsub(/[\\]/, "/").downcase}")
+      mutex.test
+    end
+
+    def runpid
+      @runpid ||= runlock.read.strip
+    end
+
+    def timeout_given?
+      !time_to_wait.nil?
+    end
+
+    def time_to_wait
+      Chef::Config[:run_lock_timeout]
+    end
+
+    def exit_from_timeout
+      rp = runpid
+      release # Just to be on the safe side...
+      raise Chef::Exceptions::RunLockTimeout.new(time_to_wait, rp)
+    end
+  end
+end