chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/{shef → shell}/model_wrapper.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -19,7 +19,7 @@
 require 'chef/mixin/convert_to_class_name'
 require 'chef/mixin/language'
 
-module Shef
+module Shell
   class ModelWrapper
 
     include Chef::Mixin::ConvertToClassName

data/lib/chef/{shef/shef_rest.rb → shell/shell_rest.rb}

@@ -6,9 +6,9 @@
 # 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.
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-module Shef
-  class ShefREST < Chef::REST
+module Shell
+  class ShellREST < Chef::REST
 
     alias :get    :get_rest
     alias :put    :put_rest

data/lib/chef/{shef/shef_session.rb → shell/shell_session.rb}

@@ -29,8 +29,8 @@ require 'chef/formatters/base'
 require 'chef/formatters/doc'
 require 'chef/formatters/minimal'
 
-module Shef
-  class ShefSession
+module Shell
+  class ShellSession
     include Singleton
 
     def self.session_type(type=nil)
@@ -55,11 +55,11 @@ module Shef
         rebuild_node
         @node = client.node
         shorten_node_inspect
-        Shef::Extensions.extend_context_node(@node)
+        Shell::Extensions.extend_context_node(@node)
         rebuild_context
         node.consume_attributes(node_attributes) if node_attributes
         @recipe = Chef::Recipe.new(nil, nil, run_context)
-        Shef::Extensions.extend_context_recipe(@recipe)
+        Shell::Extensions.extend_context_recipe(@recipe)
         @node_built = true
       end
     end
@@ -86,7 +86,7 @@ module Shef
     end
 
     def save_node
-      raise "Not Supported! #{self.class.name} doesn't support #save_node, maybe you need to run shef in client mode?"
+      raise "Not Supported! #{self.class.name} doesn't support #save_node, maybe you need to run chef-shell in client mode?"
     end
 
     def rebuild_context
@@ -137,7 +137,7 @@ module Shef
 
   end
 
-  class StandAloneSession < ShefSession
+  class StandAloneSession < ShellSession
 
     session_type :standalone
 
@@ -151,7 +151,7 @@ module Shef
 
     def rebuild_node
       Chef::Config[:solo] = true
-      @client = Chef::Client.new(nil, Chef::Config[:shell_config])
+      @client = Chef::Client.new
       @client.run_ohai
       @client.load_node
       @client.build_node
@@ -159,7 +159,7 @@ module Shef
 
   end
 
-  class SoloSession < ShefSession
+  class SoloSession < ShellSession
 
     session_type :solo
 
@@ -170,8 +170,10 @@ module Shef
     def rebuild_context
       @run_status = Chef::RunStatus.new(@node, @events)
       Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, Chef::Config[:cookbook_path]) }
-      cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(Chef::Config[:cookbook_path]))
-      @run_context = Chef::RunContext.new(node, cookbook_collection, @events)
+      cl = Chef::CookbookLoader.new(Chef::Config[:cookbook_path])
+      cl.load_cookbooks
+      cookbook_collection = Chef::CookbookCollection.new(cl)
+      @run_context = Chef::RunContext.new(node, cookbook_collection, @events) 
       @run_context.load(Chef::RunList::RunListExpansionFromDisk.new("_default", []))
       @run_status.run_context = run_context
     end
@@ -181,7 +183,7 @@ module Shef
     def rebuild_node
       # Tell the client we're chef solo so it won't try to contact the server
       Chef::Config[:solo] = true
-      @client = Chef::Client.new(nil, Chef::Config[:shell_config])
+      @client = Chef::Client.new
       @client.run_ohai
       @client.load_node
       @client.build_node
@@ -202,8 +204,8 @@ module Shef
       Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::RemoteFileVendor.new(manifest, Chef::REST.new(Chef::Config[:server_url])) }
       cookbook_hash = @client.sync_cookbooks
       cookbook_collection = Chef::CookbookCollection.new(cookbook_hash)
-      @run_context = Chef::RunContext.new(node, cookbook_collection, @events)
-      @run_context.load(@node.run_list.expand(@node.chef_environment))
+      @run_context = Chef::RunContext.new(node, cookbook_collection, @events) 
+      @run_context.load(Chef::RunList::RunListExpansionFromAPI.new("_default", []))
       @run_status.run_context = run_context
     end
 
@@ -212,7 +214,7 @@ module Shef
     def rebuild_node
       # Make sure the client knows this is not chef solo
       Chef::Config[:solo] = false
-      @client = Chef::Client.new(nil, Chef::Config[:shell_config])
+      @client = Chef::Client.new
       @client.run_ohai
       @client.register
       @client.load_node
@@ -277,7 +279,7 @@ module Shef
       puts
       Chef::Config[:doppelganger] = false
       @node_built = false
-      Shef.session
+      Shell.session
     end
 
     def rebuild_node

data/lib/chef/shell_out.rb

@@ -2,5 +2,12 @@ require 'mixlib/shellout'
 
 class Chef
   class ShellOut < Mixlib::ShellOut
+
+    def initialize(*args)
+      Chef::Log.warn("Chef::ShellOut is deprecated, please use Mixlib::ShellOut")
+      called_from = caller[0..3].inject("Called from:\n") {|msg, trace_line| msg << "  #{trace_line}\n" }
+      Chef::Log.warn(called_from)
+      super
+    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/version.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '10.34.6'
+  VERSION = '11.0.0.beta.0'
 end
 
 # NOTE: the Chef::Version class is defined in version_class.rb

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

@@ -33,7 +33,6 @@ 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,10 +26,6 @@ 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))
@@ -38,10 +34,7 @@ class Chef
       attr_reader :handle
 
       def self.close_handle_finalizer(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 }
+        proc { close_handle(handle) }
       end
 
       def self.close_handle(handle)

data/lib/chef/win32/registry.rb

@@ -0,0 +1,371 @@
+#
+# 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'
+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
+        hive, key = get_hive_and_key(key_path)
+        key_parent = key.split("\\")
+        key_to_delete = key_parent.pop
+        key_parent = key_parent.join("\\")
+        if has_subkeys?(key_path)
+          if recursive == true
+            hive.open(key_parent, ::Win32::Registry::KEY_WRITE | registry_system_architecture) do |reg|
+              Chef::Log.debug("Deleting registry key #{key_path} recursively")
+              reg.delete_key(key_to_delete,recursive)
+            end
+          else
+            raise Chef::Exceptions::Win32RegNoRecursive, "Registry key #{key_path} has subkeys, and recursive not specified"
+          end
+        else
+          hive.open(key_parent, ::Win32::Registry::KEY_WRITE | registry_system_architecture) do |reg|
+            Chef::Log.debug("Deleting registry key #{key_path}")
+            reg.delete_key(key_to_delete)
+          end
+        end
+        true
+      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