chef 11.14.0.rc.2 → 11.14.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6879b03746a23afbc56120b255c2b4c6c992eb32
+  data.tar.gz: 4e4177fbaab45b8a27ab56d0cdfd7495641b7975
+SHA512:
+  metadata.gz: 33582852620cb90c193f276dfe34cf12952132252cf3a07dfc9d5c2626126a03d74fb2fe38e13e3155de808fbd501377fc2418174a0af658d435f2c55cc5f8b7
+  data.tar.gz: ae27cdd8586f76f2904ffd88990f8149f162c84dea819a4c343c00a960017e7c318dc281a279f82b027b94aec59640a200889c6890c8fef08f185789b02dd865

data/lib/chef/formatters/base.rb

@@ -93,6 +93,13 @@ class Chef
 
       def indent_by(amount)
         @output.indent += amount
+        if @output.indent < 0
+          # This is left commented out for now.  We need to uncomment it and fix at least one bug in
+          # the formatter, and then leave this line uncommented in the future.
+          #Chef::Log.warn "Internal Formatter Error -- Attempt to indent by negative number of spaces"
+          @output.indent = 0
+        end
+        @output.indent
       end
 
       # Input: a Formatters::ErrorDescription object.

data/lib/chef/http/basic_client.rb

@@ -84,7 +84,13 @@ class Chef
       #adapted from buildr/lib/buildr/core/transports.rb
       def proxy_uri
         proxy = Chef::Config["#{url.scheme}_proxy"]
-        proxy = URI.parse(proxy) if String === proxy
+        # Check if the proxy string contains a scheme. If not, add the url's scheme to the
+        # proxy before parsing. The regex /^.*:\/\// matches, for example, http://.
+        proxy = if proxy.match(/^.*:\/\//)
+          URI.parse(proxy)
+        else
+          URI.parse("#{url.scheme}://#{proxy}")
+        end if String === proxy
         excludes = Chef::Config[:no_proxy].to_s.split(/\s*,\s*/).compact
         excludes = excludes.map { |exclude| exclude =~ /:\d+$/ ? exclude : "#{exclude}:*" }
         return proxy unless excludes.any? { |exclude| File.fnmatch(exclude, "#{host}:#{port}") }

data/lib/chef/knife/cookbook_site_share.rb

@@ -17,11 +17,14 @@
 #
 
 require 'chef/knife'
+require 'chef/mixin/shell_out'
 
 class Chef
   class Knife
     class CookbookSiteShare < Knife
 
+      include Chef::Mixin::ShellOut
+
       deps do
         require 'chef/cookbook_loader'
         require 'chef/cookbook_uploader'
@@ -56,7 +59,7 @@ class Chef
           begin
             Chef::Log.debug("Temp cookbook directory is #{tmp_cookbook_dir.inspect}")
             ui.info("Making tarball #{cookbook_name}.tgz")
-            Chef::Mixin::Command.run_command(:command => "tar -czf #{cookbook_name}.tgz #{cookbook_name}", :cwd => tmp_cookbook_dir)
+            shell_out!("tar -czf #{cookbook_name}.tgz #{cookbook_name}", :cwd => tmp_cookbook_dir)
           rescue => e
             ui.error("Error making tarball #{cookbook_name}.tgz: #{e.message}. Increase log verbosity (-VV) for more information.")
             Chef::Log.debug("\n#{e.backtrace.join("\n")}")

data/lib/chef/mixin/file_class.rb

@@ -18,13 +18,16 @@
 # limitations under the License.
 #
 
+if Chef::Platform.windows?
+  require 'chef/win32/file'
+end
+
 class Chef
   module Mixin
     module FileClass
 
       def file_class
         @host_os_file ||= if Chef::Platform.windows?
-          require 'chef/win32/file'
           Chef::ReservedNames::Win32::File
         else
           ::File

data/lib/chef/mixin/params_validate.rb

@@ -95,6 +95,13 @@ class Chef
             val = arg
           else
             val = validate({ symbol => arg }, { symbol => validation })[symbol]
+
+            # Handle the case where the "default" was a DelayedEvaluator. In
+            # this case, the block yields an optional parameter of +self+,
+            # which is the equivalent of "new_resource"
+            if val.is_a?(DelayedEvaluator)
+              val = val.call(self)
+            end
           end
           self.instance_variable_set(iv_symbol, val)
         end

data/lib/chef/provider/log.rb

@@ -25,9 +25,6 @@ class Chef
       # Chef log provider, allows logging to chef's logs from recipes
       class ChefLog < Chef::Provider
 
-        # ordered array of the log levels
-        @@levels = [ :debug, :info, :warn, :error, :fatal ]
-
         # No concept of a 'current' resource for logs, this is a no-op
         #
         # === Return
@@ -42,18 +39,7 @@ class Chef
         # true:: Always return true
         def action_write
           Chef::Log.send(@new_resource.level, @new_resource.message)
-
-          # resolve the integers for the current log levels
-          global_level = Mixlib::Log::LEVELS.fetch(Chef::Log.level)
-          resource_level = Mixlib::Log::LEVELS.fetch(@new_resource.level)
-
-          # If the resource level is greater than or the same os the global
-          # level, then it should have been written to the log.  Mark the
-          # resource as updated.
-          if resource_level >= global_level
-            @new_resource.updated_by_last_action(true)
-          end
-
+          @new_resource.updated_by_last_action(true)
         end
 
       end

data/lib/chef/provider/package/dpkg.rb

@@ -31,6 +31,7 @@ class Chef
         DPKG_VERSION = /^Version: (.+)$/
 
         include Chef::Mixin::GetSourceFromPackage
+        include Chef::Mixin::ShellOut
 
         def define_resource_requirements
           super

data/lib/chef/provider/service/windows.rb

@@ -64,9 +64,7 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
         Chef::Log.debug "#{@new_resource} already started - nothing to do"
       elsif state == START_PENDING
         Chef::Log.debug "#{@new_resource} already sent start signal - waiting for start"
-        spawn_command_thread do
-          wait_for_state(RUNNING)
-        end
+        wait_for_state(RUNNING)
       elsif state == STOPPED
         if @new_resource.start_command
           Chef::Log.debug "#{@new_resource} starting service using the given start_command"
@@ -74,8 +72,8 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
         else
           spawn_command_thread do
             Win32::Service.start(@new_resource.service_name)
-            wait_for_state(RUNNING)
           end
+          wait_for_state(RUNNING)
         end
         @new_resource.updated_by_last_action(true)
       else
@@ -96,17 +94,15 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
         else
           spawn_command_thread do
             Win32::Service.stop(@new_resource.service_name)
-            wait_for_state(STOPPED)
           end
+          wait_for_state(STOPPED)
         end
         @new_resource.updated_by_last_action(true)
       elsif state == STOPPED
         Chef::Log.debug "#{@new_resource} already stopped - nothing to do"
       elsif state == STOP_PENDING
         Chef::Log.debug "#{@new_resource} already sent stop signal - waiting for stop"
-        spawn_command_thread do
-          wait_for_state(STOPPED)
-        end
+        wait_for_state(STOPPED)
       else
         raise Chef::Exceptions::Service, "Service #{@new_resource} can't be stopped from state [#{state}]"
       end
@@ -174,7 +170,16 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
   # Helper method that waits for a status to change its state since state
   # changes aren't usually instantaneous.
   def wait_for_state(desired_state)
-    sleep 1 until current_state == desired_state
+    retries = 0
+    loop do
+      break if current_state == desired_state
+      raise Timeout::Error if ( retries += 1 ) > resource_timeout
+      sleep 1
+    end
+  end
+
+  def resource_timeout
+    @resource_timeout ||= @new_resource.timeout || TIMEOUT
   end
 
   def spawn_command_thread
@@ -182,8 +187,6 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
       yield
     end
 
-    resource_timeout = @new_resource.timeout if @new_resource.timeout
-    resource_timeout ||= TIMEOUT
     Timeout.timeout(resource_timeout) do
       worker.join
     end

data/lib/chef/resource/lwrp_base.rb

@@ -59,15 +59,17 @@ class Chef
         resource_class
       end
 
-      # Set the resource snake_case name. Should only be called via
-      # build_from_file.
-      def self.resource_name=(resource_name)
-        @resource_name = resource_name
+      # Set the resource name for this LWRP
+      def self.resource_name(arg = NULL_ARG)
+        if arg.equal?(NULL_ARG)
+          @resource_name
+        else
+          @resource_name = arg
+        end
       end
 
-      # Returns the resource snake_case name
-      def self.resource_name
-        @resource_name
+      class << self
+        alias_method :resource_name=, :resource_name
       end
 
       # Define an attribute on this resource, including optional validation
@@ -90,19 +92,39 @@ class Chef
       # Sets the default action
       def self.default_action(action_name=NULL_ARG)
         unless action_name.equal?(NULL_ARG)
-          valid_actions.push(action_name)
-          @default_action = action_name
+          @actions ||= []
+          if action_name.is_a?(Array)
+            action = action_name.map { |arg| arg.to_sym }
+            @actions = actions | action
+            @default_action = action
+          else
+            action = action_name.to_sym
+            @actions.push(action) unless @actions.include?(action)
+            @default_action = action
+          end
         end
-        @default_action
+
+        @default_action ||= from_superclass(:default_action)
       end
 
       # Adds +action_names+ to the list of valid actions for this resource.
       def self.actions(*action_names)
-        valid_actions.push(*action_names)
+        if action_names.empty?
+          defined?(@actions) ? @actions : from_superclass(:actions, []).dup
+        else
+          # BC-compat way for checking if actions have already been defined
+          if defined?(@actions)
+            @actions.push(*action_names)
+          else
+            @actions = action_names
+          end
+        end
       end
 
-      def self.valid_actions
-        @valid_actions ||= []
+      # @deprecated
+      def self.valid_actions(*args)
+        Chef::Log.warn("`valid_actions' is deprecated, please use actions `instead'!")
+        actions(*args)
       end
 
       # Set the run context on the class. Used to provide access to the node
@@ -119,12 +141,34 @@ class Chef
         run_context.node
       end
 
+      def self.lazy(&block)
+        DelayedEvaluator.new(&block)
+      end
+
+      private
+
+      # Get the value from the superclass, if it responds, otherwise return
+      # +nil+. Since class instance variables are **not** inherited upon
+      # subclassing, this is a required check to ensure Chef pulls the
+      # +default_action+ and other DSL-y methods when extending LWRP::Base.
+      def self.from_superclass(m, default = nil)
+        return default if superclass == Chef::Resource::LWRPBase
+        superclass.respond_to?(m) ? superclass.send(m) : default
+      end
+
       # Default initializer. Sets the default action and allowed actions.
       def initialize(name, run_context=nil)
         super(name, run_context)
+
+        # Raise an exception if the resource_name was not defined
+        if self.class.resource_name.nil?
+          raise Chef::Exceptions::InvalidResourceSpecification,
+            "You must specify `resource_name'!"
+        end
+
         @resource_name = self.class.resource_name.to_sym
         @action = self.class.default_action
-        allowed_actions.push(self.class.valid_actions).flatten!
+        allowed_actions.push(self.class.actions).flatten!
       end
 
     end

data/lib/chef/version.rb

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

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

@@ -0,0 +1,90 @@
+#
+# Author:: Serdar Sutay (<serdar@getchef.com>)
+# Copyright:: Copyright 2014 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/win32/api'
+
+class Chef
+  module ReservedNames::Win32
+    module API
+      module Net
+        extend Chef::ReservedNames::Win32::API
+
+        FILTER_TEMP_DUPLICATE_ACCOUNT       = 0x0001
+        FILTER_NORMAL_ACCOUNT               = 0x0002
+        FILTER_INTERDOMAIN_TRUST_ACCOUNT    = 0x0008
+        FILTER_WORKSTATION_TRUST_ACCOUNT    = 0x0010
+        FILTER_SERVER_TRUST_ACCOUNT         = 0x0020
+
+        MAX_PREFERRED_LENGTH                = 0xFFFF
+
+        NERR_Success                        = 0
+
+        ffi_lib "netapi32"
+
+        class USER_INFO_3 < FFI::Struct
+          layout :usri3_name, :LPWSTR,
+            :usri3_password, :LPWSTR,
+            :usri3_password_age, :DWORD,
+            :usri3_priv, :DWORD,
+            :usri3_home_dir, :LPWSTR,
+            :usri3_comment, :LPWSTR,
+            :usri3_flags, :DWORD,
+            :usri3_script_path, :LPWSTR,
+            :usri3_auth_flags, :DWORD,
+            :usri3_full_name, :LPWSTR,
+            :usri3_usr_comment, :LPWSTR,
+            :usri3_parms, :LPWSTR,
+            :usri3_workstations, :LPWSTR,
+            :usri3_last_logon, :DWORD,
+            :usri3_last_logoff, :DWORD,
+            :usri3_acct_expires, :DWORD,
+            :usri3_max_storage, :DWORD,
+            :usri3_units_per_week, :DWORD,
+            :usri3_logon_hours, :PBYTE,
+            :usri3_bad_pw_count, :DWORD,
+            :usri3_num_logons, :DWORD,
+            :usri3_logon_server, :LPWSTR,
+            :usri3_country_code, :DWORD,
+            :usri3_code_page, :DWORD,
+            :usri3_user_id, :DWORD,
+            :usri3_primary_group_id, :DWORD,
+            :usri3_profile, :LPWSTR,
+            :usri3_home_dir_drive, :LPWSTR,
+            :usri3_password_expired, :DWORD
+        end
+
+# NET_API_STATUS NetUserEnum(
+#   _In_     LPCWSTR servername,
+#   _In_     DWORD level,
+#   _In_     DWORD filter,
+#   _Out_    LPBYTE *bufptr,
+#   _In_     DWORD prefmaxlen,
+#   _Out_    LPDWORD entriesread,
+#   _Out_    LPDWORD totalentries,
+#   _Inout_  LPDWORD resume_handle
+# );
+        safe_attach_function :NetUserEnum, [ :LPCWSTR, :DWORD, :DWORD, :LPBYTE, :DWORD, :LPDWORD, :LPDWORD, :LPDWORD ], :DWORD
+
+# NET_API_STATUS NetApiBufferFree(
+#   _In_  LPVOID Buffer
+# );
+        safe_attach_function :NetApiBufferFree, [ :LPVOID ], :DWORD
+      end
+    end
+  end
+end

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

@@ -17,11 +17,22 @@
 #
 
 require 'chef/win32/security'
+require 'chef/win32/api/net'
+require 'chef/win32/api/error'
+
+require 'wmi-lite/wmi'
 
 class Chef
   module ReservedNames::Win32
     class Security
       class SID
+        include Chef::ReservedNames::Win32::API::Net
+        include Chef::ReservedNames::Win32::API::Error
+
+        class << self
+          include Chef::ReservedNames::Win32::API::Net
+          include Chef::ReservedNames::Win32::API::Error
+        end
 
         def initialize(pointer, owner = nil)
           @pointer = pointer
@@ -178,13 +189,11 @@ class Chef
           SID.from_string_sid('S-1-5-32-544')
         end
 
-        # Machine-specific, well-known SIDs
-        # TODO: don't use strings, dummy
         def self.None
           SID.from_account("#{::ENV['COMPUTERNAME']}\\None")
         end
         def self.Administrator
-          SID.from_account("#{::ENV['COMPUTERNAME']}\\Administrator")
+          SID.from_account("#{::ENV['COMPUTERNAME']}\\#{SID.admin_account_name}")
         end
         def self.Guest
           SID.from_account("#{::ENV['COMPUTERNAME']}\\Guest")
@@ -193,6 +202,47 @@ class Chef
         def self.current_user
           SID.from_account("#{::ENV['USERDOMAIN']}\\#{::ENV['USERNAME']}")
         end
+
+        def self.admin_account_name
+          @admin_account_name ||= begin
+            admin_account_name = nil
+
+            # Call NetUserEnum to enumerate the users without hitting network
+            # http://msdn.microsoft.com/en-us/library/windows/desktop/aa370652(v=vs.85).aspx
+            servername = nil # We are querying the local server
+            level = 3 # We want USER_INFO_3 structure which contains the SID
+            filter = FILTER_NORMAL_ACCOUNT # Only query the user accounts
+            bufptr = FFI::MemoryPointer.new(:pointer) # Buffer which will receive the data
+            prefmaxlen = MAX_PREFERRED_LENGTH # Let the system allocate the needed amount of memory
+            entriesread = FFI::Buffer.new(:long).write_long(0)
+            totalentries = FFI::Buffer.new(:long).write_long(0)
+            resume_handle = FFI::Buffer.new(:long).write_long(0)
+
+            status = ERROR_MORE_DATA
+
+            while(status == ERROR_MORE_DATA) do
+              status = NetUserEnum(servername, level, filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle)
+
+              if (status == NERR_Success || status == ERROR_MORE_DATA)
+                entriesread.read_long.times.collect do |i|
+                  user_info = USER_INFO_3.new(bufptr.read_pointer + i * USER_INFO_3.size)
+                  # Check if the account is the Administrator account
+                  # RID for the Administrator account is always 500 and it's privilage is set to USER_PRIV_ADMIN
+                  if user_info[:usri3_user_id] == 500 && user_info[:usri3_priv] == 2 # USER_PRIV_ADMIN (2) - Administrator
+                    admin_account_name = user_info[:usri3_name].read_wstring
+                    break
+                  end
+                end
+
+                # Free the memory allocated by the system
+                NetApiBufferFree(bufptr.read_pointer)
+              end
+            end
+
+            raise "Can not determine the administrator account name." if admin_account_name.nil?
+            admin_account_name
+          end
+        end
       end
     end
   end