chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/util/file_edit.rb

@@ -33,7 +33,7 @@ class Chef
         @file_edited = false
 
         raise ArgumentError, "File doesn't exist" unless File.exist? @original_pathname
-        raise ArgumentError, "File is blank" unless (@contents = File.new(@original_pathname).readlines).length > 0
+        @contents = File.new(@original_pathname).readlines
       end
 
       #search the file line by line and match each line with the given regex

data/lib/chef/util/selinux.rb

@@ -0,0 +1,100 @@
+#
+# Author:: Sean O'Meara
+# Author:: Kevin Keane
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+#
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# Copyright:: Copyright (c) 2013, North County Tech Center, LLC
+#
+# 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/shell_out'
+
+class Chef
+  class Util
+    #
+    # IMPORTANT: We assume that selinux utilities are installed on an
+    # selinux enabled server. Provisioning an selinux enabled server
+    # without selinux utilities is not supported.
+    #
+    module Selinux
+
+      include Chef::Mixin::ShellOut
+
+      # We want to initialize below variables once during a
+      # chef-client run therefore they are class variables.
+      @@selinux_enabled = nil
+      @@restorecon_path = nil
+      @@selinuxenabled_path = nil
+
+      def selinux_enabled?
+        @@selinux_enabled = check_selinux_enabled? if @@selinux_enabled.nil?
+        @@selinux_enabled
+      end
+
+      def restore_security_context(file_path, recursive = false)
+        if restorecon_path
+          restorecon_command = recursive ? "#{restorecon_path} -R -r" : "#{restorecon_path} -R"
+          restorecon_command += " #{file_path}"
+          Chef::Log.debug("Restoring selinux security content with #{restorecon_command}")
+          shell_out!(restorecon_command)
+        else
+          Chef::Log.warn "Can not find 'restorecon' on the system. Skipping selinux security context restore."
+        end
+      end
+
+      private
+
+      def restorecon_path
+        @@restorecon_path = which("restorecon") if @@restorecon_path.nil?
+        @@restorecon_path
+      end
+
+      def selinuxenabled_path
+        @@selinuxenabled_path = which("selinuxenabled") if @@selinuxenabled_path.nil?
+        @@selinuxenabled_path
+      end
+
+      def which(cmd)
+        paths = ENV['PATH'].split(File::PATH_SEPARATOR) + [ '/bin', '/usr/bin', '/sbin', '/usr/sbin' ]
+        paths.each do |path|
+          filename = File.join(path, cmd)
+          return filename if File.executable?(filename)
+        end
+        false
+      end
+
+      def check_selinux_enabled?
+        if selinuxenabled_path
+          cmd = shell_out!(selinuxenabled_path, :returns => [0,1])
+          case cmd.exitstatus
+          when 1
+            return false
+          when 0
+            return true
+          else
+            raise RuntimeError, "Unknown exit code from command #{selinuxenabled_path}: #{cmd.exitstatus}"
+          end
+        else
+          # We assume selinux is not enabled if selinux utils are not
+          # installed.
+          return false
+        end
+      end
+
+    end
+  end
+end
+

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

@@ -63,7 +63,7 @@ class Chef::Util::Windows::NetGroup < Chef::Util::Windows
         members = 0.chr * (nread * (PTR_SIZE * 3)) #nread * sizeof(LOCALGROUP_MEMBERS_INFO_1)
         memcpy(members, ptr, members.size)
 
-        # 3 pointer fields in LOCALGROUP_MEMBERS_INFO_1, offset 2*PTR_SIZE is lgrmi1_name
+        #3 pointer fields in LOCALGROUP_MEMBERS_INFO_1, offset 2*PTR_SIZE is lgrmi1_name
         nread.times do |i|
           offset = (i * 3) + 2
           member = lpwstr_to_s(members, offset)
@@ -92,10 +92,6 @@ class Chef::Util::Windows::NetGroup < Chef::Util::Windows
     modify_members(members, NetLocalGroupAddMembers)
   end
 
-  def local_delete_members(members)
-    modify_members(members, NetLocalGroupDelMembers)
-  end
-
   def local_delete
     rc = NetLocalGroupDel.call(nil, @name)
     if rc != NERR_Success

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

@@ -37,9 +37,14 @@ class Chef::Util::Windows::NetUser < Chef::Util::Windows
   #[:symbol_name, default_val]
   #default_val duals as field type
   #array index duals as structure offset
+
+  #OC-8391
+  #Changing [:password, nil], to [:password, ""],
+  #if :password is set to nil, windows user creation api ignores the password policy applied
+  #thus initializing it with empty string value.
   USER_INFO_3 = [
     [:name, nil],
-    [:password, nil],
+    [:password, ""],
     [:password_age, 0],
     [:priv, 0], #"The NetUserAdd and NetUserSetInfo functions ignore this member"
     [:home_dir, nil],
@@ -183,12 +188,20 @@ class Chef::Util::Windows::NetUser < Chef::Util::Windows
   def disable_account
     user_modify do |user|
       user[:flags] |= UF_ACCOUNTDISABLE
+      #This does not set the password to nil. It (for some reason) means to ignore updating the field.
+      #See similar behavior for the logon_hours field documented at
+      #http://msdn.microsoft.com/en-us/library/windows/desktop/aa371338%28v=vs.85%29.aspx
+      user[:password] = nil
     end
   end
 
   def enable_account
     user_modify do |user|
       user[:flags] &= ~UF_ACCOUNTDISABLE
+      #This does not set the password to nil. It (for some reason) means to ignore updating the field.      
+      #See similar behavior for the logon_hours field documented at
+      #http://msdn.microsoft.com/en-us/library/windows/desktop/aa371338%28v=vs.85%29.aspx
+      user[:password] = nil
     end
   end
 

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

@@ -51,8 +51,8 @@ class Chef::Util::Windows::Volume < Chef::Util::Windows
     end
   end
 
-  def add(device)
-    unless SetVolumeMountPoint(@name, device)
+  def add(args)
+    unless SetVolumeMountPoint(@name, args[:remote])
       raise ArgumentError, get_last_error
     end
   end

data/lib/chef/version.rb

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

data/lib/chef/version/platform.rb

@@ -0,0 +1,42 @@
+# Author:: Xabier de Zuazo (<xabier@onddo.com>)
+# Copyright:: Copyright (c) 2013 Onddo Labs, SL.
+# 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'
+
+class Chef
+  class Version
+    class Platform < Chef::Version
+
+      protected
+
+      def parse(str="")
+        @major, @minor, @patch =
+          case str.to_s
+          when /^(\d+)\.(\d+)\.(\d+)$/
+            [ $1.to_i, $2.to_i, $3.to_i ]
+          when /^(\d+)\.(\d+)$/
+            [ $1.to_i, $2.to_i, 0 ]
+          when /^(\d+)$/
+            [ $1.to_i, 0, 0 ]
+          else
+            msg = "'#{str.to_s}' does not match 'x.y.z', 'x.y' or 'x'"
+            raise Chef::Exceptions::InvalidPlatformVersion.new( msg )
+          end
+      end
+
+    end
+  end
+end

data/lib/chef/version_class.rb

@@ -51,7 +51,7 @@ class Chef
       other.is_a?(Version) && self == other
     end
 
-    private
+    protected
 
     def parse(str="")
       @major, @minor, @patch =

data/lib/chef/version_constraint.rb

@@ -22,6 +22,7 @@ class Chef
     STANDARD_OPS = %w(< > <= >=)
     OPS = %w(< > = <= >= ~>)
     PATTERN = /^(#{OPS.join('|')}) (.+)$/
+    VERSION_CLASS = Chef::Version
 
     attr_reader :op, :version
 
@@ -41,9 +42,9 @@ class Chef
 
     def include?(v)
       version = if v.respond_to? :version # a CookbookVersion-like object
-                  Chef::Version.new(v.version.to_s)
+                  self.class::VERSION_CLASS.new(v.version.to_s)
                 else
-                  Chef::Version.new(v.to_s)
+                  self.class::VERSION_CLASS.new(v.to_s)
                 end
      do_op(version)
     end
@@ -98,13 +99,13 @@ class Chef
       @missing_patch_level = false
       if str.index(" ").nil? && str =~ /^[0-9]/
         # try for lone version, implied '='
-        @version = Chef::Version.new(str)
+        @version = self.class::VERSION_CLASS.new(str)
         @op = "="
       elsif PATTERN.match str
         @op = $1
         raw_version = $2
-        @version = Chef::Version.new(raw_version)
-        if raw_version.split('.').size == 2
+        @version = self.class::VERSION_CLASS.new(raw_version)
+        if raw_version.split('.').size <= 2
           @missing_patch_level = true
         end
       else

data/lib/chef/{index_queue.rb → version_constraint/platform.rb}

@@ -1,29 +1,26 @@
-#
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# Author:: Xabier de Zuazo (<xabier@onddo.com>)
+# Copyright:: Copyright (c) 2013 Onddo Labs, SL.
 # 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 "singleton"
-require "bunny"
-
-require "chef/index_queue/amqp_client"
-require "chef/index_queue/indexable"
-require "chef/index_queue/consumer"
+require 'chef/version_constraint'
+require 'chef/version/platform'
 
 class Chef
-  module IndexQueue
+  class VersionConstraint
+    class Platform < Chef::VersionConstraint
+      VERSION_CLASS = Chef::Version::Platform
+
+    end
   end
 end

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

@@ -459,8 +459,7 @@ BOOL WINAPI DeviceIoControl(
         # to be passed to the *W vesion of WinAPI File
         # functions
         def encode_path(path)
-          path.gsub!(::File::SEPARATOR, ::File::ALT_SEPARATOR)
-          (path_prepender << path).to_wstring
+          (path_prepender << path.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR)).to_wstring
         end
 
         def path_prepender
@@ -472,6 +471,13 @@ BOOL WINAPI DeviceIoControl(
         # ensures the handle is closed on exit of the block
         def file_search_handle(path, &block)
           begin
+            # Workaround for CHEF-4419:
+            # Make sure paths starting with "/" has a drive letter
+            # assigned from the current working diretory.
+            # Note: In chef 11.8 and beyond this issue will be fixed with a
+            # broader fix to map all the paths starting with "/" to
+            # SYSTEM_DRIVE on windows.
+            path = ::File.expand_path(path) if path.start_with? "/"
             path = encode_path(path)
             find_data = WIN32_FIND_DATA.new
             handle = FindFirstFileW(path, find_data)

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

@@ -226,6 +226,50 @@ class Chef
              :SidTypeLabel
         ]
 
+        TOKEN_INFORMATION_CLASS = enum :TOKEN_INFORMATION_CLASS, [
+             :TokenUser, 1,
+             :TokenGroups,
+             :TokenPrivileges,
+             :TokenOwner,
+             :TokenPrimaryGroup,
+             :TokenDefaultDacl,
+             :TokenSource,
+             :TokenType,
+             :TokenImpersonationLevel,
+             :TokenStatistics,
+             :TokenRestrictedSids,
+             :TokenSessionId,
+             :TokenGroupsAndPrivileges,
+             :TokenSessionReference,
+             :TokenSandBoxInert,
+             :TokenAuditPolicy,
+             :TokenOrigin,
+             :TokenElevationType,
+             :TokenLinkedToken,
+             :TokenElevation,
+             :TokenHasRestrictions,
+             :TokenAccessInformation,
+             :TokenVirtualizationAllowed,
+             :TokenVirtualizationEnabled,
+             :TokenIntegrityLevel,
+             :TokenUIAccess,
+             :TokenMandatoryPolicy,
+             :TokenLogonSid,
+             :TokenIsAppContainer,
+             :TokenCapabilities,
+             :TokenAppContainerSid,
+             :TokenAppContainerNumber,
+             :TokenUserClaimAttributes,
+             :TokenDeviceClaimAttributes,
+             :TokenRestrictedUserClaimAttributes,
+             :TokenRestrictedDeviceClaimAttributes,
+             :TokenDeviceGroups,
+             :TokenRestrictedDeviceGroups,
+             :TokenSecurityAttributes,
+             :TokenIsRestricted,
+             :MaxTokenInfoClass
+        ]
+
         # SECURITY_DESCRIPTOR is an opaque structure whose contents can vary.  Pass the
         # pointer around and free it with LocalFree.
         # http://msdn.microsoft.com/en-us/library/windows/desktop/aa379561(v=vs.85).aspx
@@ -334,7 +378,7 @@ class Chef
         safe_attach_function :SetSecurityDescriptorGroup, [ :pointer, :pointer, :BOOL ], :BOOL
         safe_attach_function :SetSecurityDescriptorOwner, [ :pointer, :pointer, :BOOL ], :BOOL
         safe_attach_function :SetSecurityDescriptorSacl, [ :pointer, :BOOL, :pointer, :BOOL ], :BOOL
-
+        safe_attach_function :GetTokenInformation, [ :HANDLE, :TOKEN_INFORMATION_CLASS, :pointer, :DWORD, :PDWORD ], :BOOL
       end
     end
   end

data/lib/chef/win32/registry.rb

@@ -0,0 +1,382 @@
+#
+# Author:: Prajakta Purohit (<prajakta@opscode.com>)
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+#
+# Copyright:: 2012, Opscode, Inc.
+#
+# 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/reserved_names'
+
+if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+  require 'win32/registry'
+  require 'ruby-wmi'
+  require 'win32/api'
+end
+
+class Chef
+  class Win32
+    class Registry
+
+      attr_accessor :run_context
+      attr_accessor :architecture
+
+      def initialize(run_context=nil, user_architecture=:machine)
+        @run_context = run_context
+        self.architecture = user_architecture
+      end
+
+      def architecture=(user_architecture)
+        @architecture = user_architecture.to_sym
+        assert_architecture!
+      end
+
+      def get_values(key_path)
+        hive, key = get_hive_and_key(key_path)
+        key_exists!(key_path)
+        values = hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
+          reg.map { |name, type, data| {:name=>name, :type=>get_name_from_type(type), :data=>data} }
+        end
+      end
+
+      def set_value(key_path, value)
+        Chef::Log.debug("Updating value #{value[:name]} in registry key #{key_path} with type #{value[:type]} and data #{value[:data]}")
+        key_exists!(key_path)
+        hive, key = get_hive_and_key(key_path)
+        if value_exists?(key_path, value)
+          if data_exists?(key_path, value)
+            Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} already had those values, not updated")
+            return false
+          else
+            hive.open(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry_system_architecture) do |reg|
+              reg.write(value[:name], get_type_from_name(value[:type]), value[:data])
+            end
+            Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} updated")
+          end
+        else
+          hive.open(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry_system_architecture) do |reg|
+            reg.write(value[:name], get_type_from_name(value[:type]), value[:data])
+          end
+          Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} created")
+        end
+        true
+      end
+
+      def delete_value(key_path, value)
+        Chef::Log.debug("Deleting value #{value[:name]} from registry key #{key_path}")
+        if value_exists?(key_path, value)
+          begin
+            hive, key = get_hive_and_key(key_path)
+          rescue Chef::Exceptions::Win32RegKeyMissing
+            return true
+          end
+          hive.open(key, ::Win32::Registry::KEY_SET_VALUE | registry_system_architecture) do |reg|
+            reg.delete_value(value[:name])
+            Chef::Log.debug("Deleted value #{value[:name]} from registry key #{key_path}")
+          end
+        else
+          Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} does not exist, not updated")
+        end
+        true
+      end
+
+      def create_key(key_path, recursive)
+        Chef::Log.debug("Creating registry key #{key_path}")
+        if keys_missing?(key_path)
+          if recursive == true
+            Chef::Log.debug("Registry key #{key_path} has missing subkeys, and recursive specified, creating them....")
+            create_missing(key_path)
+          else
+            raise Chef::Exceptions::Win32RegNoRecursive, "Registry key #{key_path} has missing subkeys, and recursive not specified"
+          end
+        end
+        if key_exists?(key_path)
+          Chef::Log.debug("Registry key #{key_path} already exists, doing nothing")
+        else
+          hive, key = get_hive_and_key(key_path)
+          hive.create(key, ::Win32::Registry::KEY_WRITE | registry_system_architecture)
+          Chef::Log.debug("Registry key #{key_path} created")
+        end
+        true
+      end
+
+      def delete_key(key_path, recursive)
+        Chef::Log.debug("Deleting registry key #{key_path}")
+        unless key_exists?(key_path)
+          Chef::Log.debug("Registry key #{key_path}, does not exist, not deleting")
+          return true
+        end
+        #key_path is in the form "HKLM\Software\Opscode" for example, extracting
+        #hive = HKLM,
+        #hive_namespace = ::Win32::Registry::HKEY_LOCAL_MACHINE
+        hive = key_path.split("\\").shift
+        hive_namespace, key_including_parent = get_hive_and_key(key_path)
+        if has_subkeys?(key_path)
+          if recursive == true
+            subkeys = get_subkeys(key_path)
+            subkeys.each do |key|
+              keypath_to_check = hive+"\\"+key_including_parent+"\\"+key
+              Chef::Log.debug("Deleting registry key #{key_path} recursively")
+              delete_key(keypath_to_check, true)
+            end
+            delete_key_ex(hive_namespace, key_including_parent)
+          else
+            raise Chef::Exceptions::Win32RegNoRecursive, "Registry key #{key_path} has subkeys, and recursive not specified"
+          end
+        else
+          delete_key_ex(hive_namespace, key_including_parent)
+          return true
+        end
+        true
+      end
+
+      #Using the 'RegDeleteKeyEx' Windows API that correctly supports WOW64 systems (Win2003)
+      #instead of the 'RegDeleteKey'
+      def delete_key_ex(hive, key)
+        regDeleteKeyEx = ::Win32::API.new('RegDeleteKeyEx', 'LPLL', 'L', 'advapi32')
+        hive_num = hive.hkey - (1 << 32)
+        regDeleteKeyEx.call(hive_num, key, ::Win32::Registry::KEY_WRITE | registry_system_architecture, 0)
+      end
+
+      def key_exists?(key_path)
+        hive, key = get_hive_and_key(key_path)
+        begin
+          hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |current_key|
+            return true
+          end
+        rescue ::Win32::Registry::Error => e
+          return false
+        end
+      end
+
+      def key_exists!(key_path)
+        unless key_exists?(key_path)
+          raise Chef::Exceptions::Win32RegKeyMissing, "Registry key #{key_path} does not exist"
+        end
+        true
+      end
+
+      def hive_exists?(key_path)
+        begin
+          hive, key = get_hive_and_key(key_path)
+        rescue Chef::Exceptions::Win32RegHiveMissing => e
+          return false
+        end
+        return true
+      end
+
+      def has_subkeys?(key_path)
+        key_exists!(key_path)
+        hive, key = get_hive_and_key(key_path)
+        hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
+          reg.each_key{ |key| return true }
+        end
+        return false
+      end
+
+      def get_subkeys(key_path)
+        subkeys = []
+        key_exists!(key_path)
+        hive, key = get_hive_and_key(key_path)
+        hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
+          reg.each_key{ |current_key| subkeys << current_key }
+        end
+        return subkeys
+      end
+
+      # 32-bit chef clients running on 64-bit machines will default to reading the 64-bit registry
+      def registry_system_architecture
+        applied_arch = ( architecture == :machine ) ? machine_architecture : architecture
+        ( applied_arch == :x86_64 ) ? 0x0100 : 0x0200
+      end
+
+      def value_exists?(key_path, value)
+        key_exists!(key_path)
+        hive, key = get_hive_and_key(key_path)
+        hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
+          return true if reg.any? {|val| val == value[:name] }
+        end
+        return false
+      end
+
+      def data_exists?(key_path, value)
+        key_exists!(key_path)
+        hive, key = get_hive_and_key(key_path)
+        hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
+          reg.each do |val_name, val_type, val_data|
+            if val_name == value[:name] &&
+              val_type == get_type_from_name(value[:type]) &&
+              val_data == value[:data]
+              return true
+            end
+          end
+        end
+        return false
+      end
+
+      def value_exists!(key_path, value)
+        unless value_exists?(key_path, value)
+          raise Chef::Exceptions::Win32RegValueMissing, "Registry key #{key_path} has no value named #{value[:name]}"
+        end
+        true
+      end
+
+      def data_exists!(key_path, value)
+        unless data_exists?(key_path, value)
+          raise Chef::Exceptions::Win32RegDataMissing, "Registry key #{key_path} has no value named #{value[:name]}, containing type #{value[:type]} and data #{value[:data]}"
+        end
+        true
+      end
+
+      def type_matches?(key_path, value)
+        value_exists!(key_path, value)
+        hive, key = get_hive_and_key(key_path)
+        hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
+          reg.each do |val_name, val_type|
+            if val_name == value[:name]
+              type_new = get_type_from_name(value[:type])
+              if val_type == type_new
+                return true
+              end
+            end
+          end
+        end
+        return false
+      end
+
+      def type_matches!(key_path, value)
+        unless type_matches?(key_path, value)
+          raise Chef::Exceptions::Win32RegTypesMismatch, "Registry key #{key_path} has a value #{value[:name]} with a type that is not #{value[:type]}"
+        end
+      end
+
+      def get_type_from_name(val_type)
+        value = {
+          :binary => ::Win32::Registry::REG_BINARY,
+          :string => ::Win32::Registry::REG_SZ,
+          :multi_string => ::Win32::Registry::REG_MULTI_SZ,
+          :expand_string => ::Win32::Registry::REG_EXPAND_SZ,
+          :dword => ::Win32::Registry::REG_DWORD,
+          :dword_big_endian => ::Win32::Registry::REG_DWORD_BIG_ENDIAN,
+          :qword => ::Win32::Registry::REG_QWORD
+        }[val_type]
+        return value
+      end
+
+      def keys_missing?(key_path)
+        missing_key_arr = key_path.split("\\")
+        missing_key_arr.pop
+        key = missing_key_arr.join("\\")
+        !key_exists?(key)
+      end
+
+      def get_type_from_name(val_type)
+        _type_name_map[val_type]
+      end
+
+      def get_name_from_type(val_class)
+        _name_type_map[val_class]
+      end
+
+      private
+
+      def node
+        run_context && run_context.node
+      end
+
+      def machine_architecture
+        node[:kernel][:machine].to_sym
+      end
+
+      def assert_architecture!
+        if machine_architecture == :i386 && architecture == :x86_64
+          raise Chef::Exceptions::Win32RegArchitectureIncorrect, "cannot access 64-bit registry on a 32-bit windows instance"
+        end
+      end
+
+      def get_hive_and_key(path)
+        reg_path = path.split("\\")
+        hive_name = reg_path.shift
+        key = reg_path.join("\\")
+
+        hive = {
+          "HKLM" => ::Win32::Registry::HKEY_LOCAL_MACHINE,
+          "HKEY_LOCAL_MACHINE" => ::Win32::Registry::HKEY_LOCAL_MACHINE,
+          "HKU" => ::Win32::Registry::HKEY_USERS,
+          "HKEY_USERS" => ::Win32::Registry::HKEY_USERS,
+          "HKCU" => ::Win32::Registry::HKEY_CURRENT_USER,
+          "HKEY_CURRENT_USER" => ::Win32::Registry::HKEY_CURRENT_USER,
+          "HKCR" => ::Win32::Registry::HKEY_CLASSES_ROOT,
+          "HKEY_CLASSES_ROOT" => ::Win32::Registry::HKEY_CLASSES_ROOT,
+          "HKCC" => ::Win32::Registry::HKEY_CURRENT_CONFIG,
+          "HKEY_CURRENT_CONFIG" => ::Win32::Registry::HKEY_CURRENT_CONFIG,
+        }[hive_name]
+
+        raise Chef::Exceptions::Win32RegHiveMissing, "Registry Hive #{hive_name} does not exist" unless hive
+
+        return hive, key
+      end
+
+      def _type_name_map
+        {
+          :binary => ::Win32::Registry::REG_BINARY,
+          :string => ::Win32::Registry::REG_SZ,
+          :multi_string => ::Win32::Registry::REG_MULTI_SZ,
+          :expand_string => ::Win32::Registry::REG_EXPAND_SZ,
+          :dword => ::Win32::Registry::REG_DWORD,
+          :dword_big_endian => ::Win32::Registry::REG_DWORD_BIG_ENDIAN,
+          :qword => ::Win32::Registry::REG_QWORD
+        }
+      end
+
+      def _name_type_map
+        @_name_type_map ||= _type_name_map.invert
+      end
+
+      def get_type_from_num(val_type)
+        value = {
+          3 => ::Win32::Registry::REG_BINARY,
+          1 => ::Win32::Registry::REG_SZ,
+          7 => ::Win32::Registry::REG_MULTI_SZ,
+          2 => ::Win32::Registry::REG_EXPAND_SZ,
+          4 => ::Win32::Registry::REG_DWORD,
+          5 => ::Win32::Registry::REG_DWORD_BIG_ENDIAN,
+          11 => ::Win32::Registry::REG_QWORD
+        }[val_type]
+        return value
+      end
+
+      def create_missing(key_path)
+        missing_key_arr = key_path.split("\\")
+        hivename = missing_key_arr.shift
+        missing_key_arr.pop
+        existing_key_path = hivename
+        hive, key = get_hive_and_key(key_path)
+        missing_key_arr.each do |intermediate_key|
+          existing_key_path = existing_key_path << "\\" << intermediate_key
+          if !key_exists?(existing_key_path)
+            Chef::Log.debug("Recursively creating registry key #{existing_key_path}")
+            hive.create(get_key(existing_key_path), ::Win32::Registry::KEY_ALL_ACCESS | registry_system_architecture)
+          end
+        end
+      end
+
+      def get_key(path)
+        reg_path = path.split("\\")
+        hive_name = reg_path.shift
+        key = reg_path.join("\\")
+      end
+
+    end
+  end
+end