chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -82,6 +82,21 @@ class Chef
           qualified_recipe
         end
       end
+
+      # Get an array of strings of both fully-qualified and unexpanded recipe names
+      # in response to chef/chef#3767
+      # Chef-13 will revert to the behaviour of just including the fully-qualified name
+      #
+      # @return [Array] Array of strings with fully-qualified and unexpanded recipe names
+      def with_duplicate_names
+        self.map do |recipe_name|
+          if recipe_name.include?('::')
+            recipe_name
+          else
+            [recipe_name, "#{recipe_name}::default"]
+          end
+        end.flatten
+      end
     end
   end
 end

data/lib/chef/run_lock.rb

@@ -87,27 +87,8 @@ class Chef
     # Either acquire() or test() methods should be called in order to
     # get the ownership of run_lock.
     def test
-      # ensure the runlock_file path exists
-      create_path(File.dirname(runlock_file))
-      @runlock = File.open(runlock_file,'a+')
-
-      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
+      create_lock
+      acquire_lock
     end
 
     #
@@ -147,6 +128,34 @@ class Chef
       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

data/lib/chef/util/powershell/ps_credential.rb

@@ -29,6 +29,10 @@ class Chef::Util::Powershell
       "New-Object System.Management.Automation.PSCredential('#{@username}',('#{encrypt(@password)}' | ConvertTo-SecureString))"
     end
 
+    def to_s
+      to_psobject
+    end
+
     private
 
     def encrypt(str)

data/lib/chef/util/windows.rb

@@ -15,42 +15,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-#requires: gem install windows-pr
-require 'windows/api'
-require 'windows/error'
-require 'windows/handle'
-require 'windows/unicode'
-require 'windows/msvcrt/buffer'
-require 'windows/msvcrt/string'
-require 'windows/network/management'
 
 class Chef
   class Util
     class Windows
-      protected
-
-      include ::Windows::Error
-      include ::Windows::Unicode
-      include ::Windows::MSVCRT::Buffer
-      include ::Windows::MSVCRT::String
-      include ::Windows::Network::Management
-
-      PTR_SIZE = 4 #XXX 64-bit
-
-      def lpwstr_to_s(buffer, offset)
-        str = 0.chr * (256 * 2) #XXX unhardcode this length (*2 for WCHAR)
-        wcscpy str, buffer[offset*PTR_SIZE,PTR_SIZE].unpack('L')[0]
-        wide_to_multi str
-      end
-
-      def dword_to_i(buffer, offset)
-        buffer[offset*PTR_SIZE,PTR_SIZE].unpack('i')[0] || 0
-      end
-
-      #return pointer for use with pack('L')
-      def str_to_ptr(v)
-        [v].pack('p*').unpack('L')[0]
-      end
     end
   end
 end

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

@@ -1,106 +1,85 @@
-#
-# Author:: Doug MacEachern (<dougm@vmware.com>)
-# Copyright:: Copyright (c) 2010 VMware, 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/util/windows'
-
-#wrapper around a subset of the NetGroup* APIs.
-#nothing Chef specific, but not complete enough to be its own gem, so util for now.
-class Chef::Util::Windows::NetGroup < Chef::Util::Windows
-
-  private
-
-  def pack_str(s)
-    [str_to_ptr(s)].pack('L')
-  end
-
-  def modify_members(members, func)
-    buffer = 0.chr * (members.size * PTR_SIZE)
-    members.each_with_index do |member,offset|
-      buffer[offset*PTR_SIZE,PTR_SIZE] = pack_str(multi_to_wide(member))
-    end
-    rc = func.call(nil, @name, 3, buffer, members.size)
-    if rc != NERR_Success
-      raise ArgumentError, get_last_error(rc)
-    end
-  end
-
-  public
-
-  def initialize(groupname)
-    @name = multi_to_wide(groupname)
-  end
-
-  def local_get_members
-    group_members = []
-    handle = 0.chr * PTR_SIZE
-    rc = ERROR_MORE_DATA
-
-    while rc == ERROR_MORE_DATA
-      ptr   = 0.chr * PTR_SIZE
-      nread = 0.chr * PTR_SIZE
-      total = 0.chr * PTR_SIZE
-
-      rc = NetLocalGroupGetMembers.call(nil, @name, 0, ptr, -1,
-                                        nread, total, handle)
-      if (rc == NERR_Success) || (rc == ERROR_MORE_DATA)
-        ptr = ptr.unpack('L')[0]
-        nread = nread.unpack('i')[0]
-        members = 0.chr * (nread * PTR_SIZE ) #nread * sizeof(LOCALGROUP_MEMBERS_INFO_0)
-        memcpy(members, ptr, members.size)
-
-        # 1 pointer field in LOCALGROUP_MEMBERS_INFO_0, offset 0 is lgrmi0_sid
-        nread.times do |i|
-          sid_address = members[i * PTR_SIZE, PTR_SIZE].unpack('L')[0]
-          sid_ptr = FFI::Pointer.new(sid_address)
-          member_sid = Chef::ReservedNames::Win32::Security::SID.new(sid_ptr)
-          group_members << member_sid.to_s
-        end
-        NetApiBufferFree(ptr)
-      else
-        raise ArgumentError, get_last_error(rc)
-      end
-    end
-    group_members
-  end
-
-  def local_add
-    rc = NetLocalGroupAdd.call(nil, 0, pack_str(@name), nil)
-    if rc != NERR_Success
-      raise ArgumentError, get_last_error(rc)
-    end
-  end
-
-  def local_set_members(members)
-    modify_members(members, NetLocalGroupSetMembers)
-  end
-
-  def local_add_members(members)
-    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
-      raise ArgumentError, get_last_error(rc)
-    end
-  end
-end
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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/util/windows'
+require 'chef/win32/net'
+
+#wrapper around a subset of the NetGroup* APIs.
+class Chef::Util::Windows::NetGroup
+
+  private
+
+  def groupname
+    @groupname
+  end
+
+  public
+
+  def initialize(groupname)
+    @groupname = groupname
+  end
+
+  def local_get_members
+    begin
+      Chef::ReservedNames::Win32::NetUser::net_local_group_get_members(nil, groupname)
+    rescue Chef::Exceptions::Win32NetAPIError => e
+      raise ArgumentError, e.msg
+    end
+  end
+
+  def local_add
+    begin
+      Chef::ReservedNames::Win32::NetUser::net_local_group_add(nil, groupname)
+    rescue Chef::Exceptions::Win32NetAPIError => e
+      raise ArgumentError, e.msg
+    end
+  end
+
+  def local_set_members(members)
+    begin
+      Chef::ReservedNames::Win32::NetUser::net_local_group_set_members(nil, groupname, members)
+    rescue Chef::Exceptions::Win32NetAPIError => e
+      raise ArgumentError, e.msg
+    end
+  end
+
+  def local_add_members(members)
+    begin
+      Chef::ReservedNames::Win32::NetUser::net_local_group_add_members(nil, groupname, members)
+    rescue Chef::Exceptions::Win32NetAPIError => e
+      raise ArgumentError, e.msg
+    end
+  end
+
+  def local_delete_members(members)
+    begin
+      Chef::ReservedNames::Win32::NetUser::net_local_group_del_members(nil, groupname, members)
+    rescue Chef::Exceptions::Win32NetAPIError => e
+      raise ArgumentError, e.msg
+    end
+
+  end
+
+  def local_delete
+    begin
+      Chef::ReservedNames::Win32::NetUser::net_local_group_del(nil, groupname)
+    rescue Chef::Exceptions::Win32NetAPIError => e
+      raise ArgumentError, e.msg
+    end
+  end
+end

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

@@ -21,61 +21,18 @@
 #see also cmd.exe: net use /?
 
 require 'chef/util/windows'
+require 'chef/win32/net'
 
 class Chef::Util::Windows::NetUse < Chef::Util::Windows
-
-  private
-
-  USE_NOFORCE = 0
-  USE_FORCE = 1
-  USE_LOTS_OF_FORCE = 2 #every windows API should support this flag
-
-  USE_INFO_2 = [
-    [:local, nil],
-    [:remote, nil],
-    [:password, nil],
-    [:status, 0],
-    [:asg_type, 0],
-    [:refcount, 0],
-    [:usecount, 0],
-    [:username, nil],
-    [:domainname, nil]
-  ]
-
-  USE_INFO_2_TEMPLATE =
-    USE_INFO_2.collect { |field| field[1].class == Fixnum ? 'i' : 'L' }.join
-
-  SIZEOF_USE_INFO_2 = #sizeof(USE_INFO_2)
-    USE_INFO_2.inject(0) do |sum, item|
-      sum + (item[1].class == Fixnum ? 4 : PTR_SIZE)
-    end
-
-  def use_info_2(args)
-    USE_INFO_2.collect { |field|
-      args.include?(field[0]) ? args[field[0]] : field[1]
-    }
-  end
-
-  def use_info_2_pack(use)
-    use.collect { |v|
-      v.class == Fixnum ? v : str_to_ptr(multi_to_wide(v))
-    }.pack(USE_INFO_2_TEMPLATE)
+  def initialize(localname)
+    @use_name = localname
   end
 
-  def use_info_2_unpack(buffer)
-    use = Hash.new
-    USE_INFO_2.each_with_index do |field,offset|
-      use[field[0]] = field[1].class == Fixnum ?
-      dword_to_i(buffer, offset) : lpwstr_to_s(buffer, offset)
+  def to_ui2_struct(use_info)
+    use_info.inject({}) do |memo, (k,v)|
+      memo["ui2_#{k}".to_sym] = v
+      memo
     end
-    use
-  end
-
-  public
-
-  def initialize(localname)
-    @localname = localname
-    @name = multi_to_wide(localname)
   end
 
   def add(args)
@@ -84,38 +41,45 @@ class Chef::Util::Windows::NetUse < Chef::Util::Windows
       args = Hash.new
       args[:remote] = remote
     end
-    args[:local] ||= @localname
-    use = use_info_2(args)
-    buffer = use_info_2_pack(use)
-    rc = NetUseAdd.call(nil, 2, buffer, nil)
-    if rc != NERR_Success
-      raise ArgumentError, get_last_error(rc)
+    args[:local] ||= use_name
+    ui2_hash = to_ui2_struct(args)
+
+    begin
+      Chef::ReservedNames::Win32::Net.net_use_add_l2(nil, ui2_hash)
+    rescue Chef::Exceptions::Win32APIError => e
+      raise ArgumentError, e
     end
   end
 
-  def get_info
-    ptr  = 0.chr * PTR_SIZE
-    rc = NetUseGetInfo.call(nil, @name, 2, ptr)
-
-    if rc != NERR_Success
-      raise ArgumentError, get_last_error(rc)
+  def from_use_info_struct(ui2_hash)
+    ui2_hash.inject({}) do |memo, (k,v)|
+      memo[k.to_s.sub('ui2_', '').to_sym] = v
+      memo
     end
+  end
 
-    ptr = ptr.unpack('L')[0]
-    buffer = 0.chr * SIZEOF_USE_INFO_2
-    memcpy(buffer, ptr, buffer.size)
-    NetApiBufferFree(ptr)
-    use_info_2_unpack(buffer)
+  def get_info
+    begin
+      ui2 = Chef::ReservedNames::Win32::Net.net_use_get_info_l2(nil, use_name)
+      from_use_info_struct(ui2)
+    rescue Chef::Exceptions::Win32APIError => e
+      raise ArgumentError, e
+    end
   end
 
   def device
     get_info()[:remote]
   end
-  #XXX should we use some FORCE here?
+
   def delete
-    rc = NetUseDel.call(nil, @name, USE_NOFORCE)
-    if rc != NERR_Success
-      raise ArgumentError, get_last_error(rc)
+    begin
+      Chef::ReservedNames::Win32::Net.net_use_del(nil, use_name, :use_noforce)
+    rescue Chef::Exceptions::Win32APIError => e
+      raise ArgumentError, e
     end
   end
+
+  def use_name
+    @use_name
+  end
 end