chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/lib/chef/knife/status.rb

@@ -17,13 +17,13 @@
 #
 
 require 'chef/knife'
+require 'chef/knife/core/status_presenter'
 
 class Chef
   class Knife
     class Status < Knife
 
       deps do
-        require 'highline'
         require 'chef/search/query'
       end
 
@@ -44,74 +44,27 @@ class Chef
         :long => "--hide-healthy",
         :description => "Hide nodes that have run chef in the last hour"
 
-      def highline
-        @h ||= HighLine.new
-      end
-
       def run
+        ui.use_presenter Knife::Core::StatusPresenter
         all_nodes = []
         q = Chef::Search::Query.new
-        query = @name_args[0] || "*:*"
+        query = @name_args[0] ? @name_args[0].dup : '*:*' 
+        if config[:hide_healthy]
+          time = Time.now.to_i
+          query_unhealthy = "NOT ohai_time:[" << (time - 60*60).to_s << " TO " << time.to_s << "]"
+          query << ' AND ' << query_unhealthy << @name_args[0] if @name_args[0]
+          query = query_unhealthy unless @name_args[0]
+        end
         q.search(:node, query) do |node|
           all_nodes << node
         end
-        all_nodes.sort { |n1, n2|
+        output(all_nodes.sort { |n1, n2|
           if (config[:sort_reverse] || Chef::Config[:knife][:sort_status_reverse])
             (n2["ohai_time"] or 0) <=> (n1["ohai_time"] or 0)
           else
             (n1["ohai_time"] or 0) <=> (n2["ohai_time"] or 0)
           end
-        }.each do |node|
-          if node.has_key?("ec2")
-            fqdn = node['ec2']['public_hostname']
-            ipaddress = node['ec2']['public_ipv4']
-          else
-            fqdn = node['fqdn']
-            ipaddress = node['ipaddress']
-          end
-          hours, minutes, seconds = time_difference_in_hms(node["ohai_time"])
-          hours_text   = "#{hours} hour#{hours == 1 ? ' ' : 's'}"
-          minutes_text = "#{minutes} minute#{minutes == 1 ? ' ' : 's'}"
-          run_list = "#{node.run_list}" if config[:run_list]
-          if hours > 24
-            color = :red
-            text = hours_text
-          elsif hours >= 1
-            color = :yellow
-            text = hours_text
-          else
-            color = :green
-            text = minutes_text
-          end
-
-          line_parts = Array.new
-          line_parts << @ui.color(text, color) + " ago" << node.name
-          line_parts << fqdn if fqdn
-          line_parts << ipaddress if ipaddress
-          line_parts << run_list if run_list
-
-          if node['platform']
-            platform = node['platform']
-            if node['platform_version']
-              platform << " #{node['platform_version']}"
-            end
-            line_parts << platform
-          end
-          highline.say(line_parts.join(', ') + '.') unless (config[:hide_healthy] && hours < 1)
-        end
-
-      end
-
-      # :nodoc:
-      # TODO: this is duplicated from StatusHelper in the Webui. dedup.
-      def time_difference_in_hms(unix_time)
-        now = Time.now.to_i
-        difference = now - unix_time.to_i
-        hours = (difference / 3600).to_i
-        difference = difference % 3600
-        minutes = (difference / 60).to_i
-        seconds = (difference % 60)
-        return [hours, minutes, seconds]
+        })
       end
 
     end

data/lib/chef/mixin/command/unix.rb

@@ -100,9 +100,9 @@ class Chef
 
               begin
                 if cmd.kind_of?(Array)
-                  exec(*cmd)
+                  Kernel.exec(*cmd)
                 else
-                  exec(cmd)
+                  Kernel.exec(cmd)
                 end
                 raise 'forty-two'
               rescue Exception => e

data/lib/chef/mixin/convert_to_class_name.rb

@@ -61,6 +61,60 @@ class Chef
         base.to_s + (file_base == 'default' ? '' : "_#{file_base}")
       end
 
+      # Copied from rails activesupport.  In ruby >= 2.0 const_get will just do this, so this can
+      # be deprecated and removed.
+      #
+      # MIT LICENSE is here: https://github.com/rails/rails/blob/master/activesupport/MIT-LICENSE
+
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   'Module'.constantize     # => Module
+      #   'Test::Unit'.constantize # => Test::Unit
+      #
+      # The name is assumed to be the one of a top-level constant, no matter
+      # whether it starts with "::" or not. No lexical context is taken into
+      # account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C               # => 'inside'
+      #     'C'.constantize # => 'outside', same as ::C
+      #   end
+      #
+      # NameError is raised when the name is not in CamelCase or the constant is
+      # unknown.
+      def constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+
     end
   end
 end

data/lib/chef/mixin/descendants_tracker.rb

@@ -0,0 +1,82 @@
+#
+# Copyright (c) 2005-2012 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+
+# This is lifted from rails activesupport (note the copyright above):
+# https://github.com/rails/rails/blob/9f84e60ac9d7bf07d6ae1bc94f3941f5b8f1a228/activesupport/lib/active_support/descendants_tracker.rb
+
+class Chef
+  module Mixin
+    module DescendantsTracker
+      @@direct_descendants = {}
+
+      class << self
+        def direct_descendants(klass)
+          @@direct_descendants[klass] || []
+        end
+
+        def descendants(klass)
+          arr = []
+          accumulate_descendants(klass, arr)
+          arr
+        end
+
+        def find_descendants_by_name(klass, name)
+          descendants(klass).first {|c| c.name == name }
+        end
+
+        # This is the only method that is not thread safe, but is only ever called
+        # during the eager loading phase.
+        def store_inherited(klass, descendant)
+          (@@direct_descendants[klass] ||= []) << descendant
+        end
+
+        private
+
+        def accumulate_descendants(klass, acc)
+          if direct_descendants = @@direct_descendants[klass]
+            acc.concat(direct_descendants)
+            direct_descendants.each { |direct_descendant| accumulate_descendants(direct_descendant, acc) }
+          end
+        end
+      end
+
+      def inherited(base)
+        DescendantsTracker.store_inherited(self, base)
+        super
+      end
+
+      def direct_descendants
+        DescendantsTracker.direct_descendants(self)
+      end
+
+      def find_descendants_by_name(name)
+        DescendantsTracker.find_descendants_by_name(self, name)
+      end
+
+      def descendants
+        DescendantsTracker.descendants(self)
+      end
+    end
+  end
+end

data/lib/chef/mixin/homebrew_user.rb

@@ -0,0 +1,68 @@
+#
+# Author:: Joshua Timberman (<joshua@getchef.com>)
+# Author:: Graeme Mathieson (<mathie@woss.name>)
+#
+# Copyright 2011-2013, Opscode, Inc.
+# Copyright 2014, Chef Software, Inc <legal@getchef.com>
+#
+# 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.
+#
+# Ported from the homebrew cookbook's Homebrew::Mixin owner helpers
+#
+# This lives here in Chef::Mixin because Chef's namespacing makes it
+# awkward to use modules elsewhere (e.g., chef/provider/package/homebrew/owner)
+
+require 'chef/mixin/shell_out'
+require 'etc'
+
+class Chef
+  module Mixin
+    module HomebrewUser
+      include Chef::Mixin::ShellOut
+
+      ##
+      # This tries to find the user to execute brew as.  If a user is provided, that overrides the brew
+      # executable user.  It is an error condition if the brew executable owner is root or we cannot find
+      # the brew executable.
+      def find_homebrew_uid(provided_user = nil)
+        # They could provide us a user name or a UID
+        if provided_user
+          return provided_user if provided_user.is_a? Integer
+          return Etc.getpwnam(provided_user).uid
+        end
+
+        @homebrew_owner ||= calculate_owner
+        @homebrew_owner
+      end
+
+      private
+
+      def calculate_owner
+        default_brew_path = '/usr/local/bin/brew'
+        if ::File.exist?(default_brew_path)
+          # By default, this follows symlinks which is what we want
+          owner = ::File.stat(default_brew_path).uid
+        elsif (brew_path = shell_out("which brew").stdout.strip) && !brew_path.empty?
+          owner = ::File.stat(brew_path).uid
+        else
+          raise Chef::Exceptions::CannotDetermineHomebrewOwner,
+                'Could not find the "brew" executable in /usr/local/bin or anywhere on the path.'
+        end
+
+        Chef::Log.debug "Found Homebrew owner #{Etc.getpwuid(owner).name}; executing `brew` commands as them"
+        owner
+      end
+
+    end
+  end
+end

data/lib/chef/mixin/shell_out.rb

@@ -15,10 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# chef/shell_out has been deprecated in favor of mixlib/shellout
-# chef/shell_out is still required here to ensure backward compatibility
-require 'chef/shell_out'
-
 require 'mixlib/shellout'
 
 class Chef

data/lib/chef/mixin/windows_architecture_helper.rb

@@ -42,6 +42,22 @@ class Chef
           is_i386_process_on_x86_64_windows?
       end
 
+      def with_os_architecture(node)
+        wow64_redirection_state = nil
+
+        if wow64_architecture_override_required?(node, node_windows_architecture(node))
+          wow64_redirection_state = disable_wow64_file_redirection(node)
+        end
+
+        begin
+          yield
+        ensure
+          if wow64_redirection_state
+            restore_wow64_file_redirection(node, wow64_redirection_state)
+          end
+        end
+      end
+
       def node_supports_windows_architecture?(node, desired_architecture)
         assert_valid_windows_architecture!(desired_architecture)
         return (node_windows_architecture(node) == :x86_64 ||

data/lib/chef/mixin/windows_env_helper.rb

@@ -0,0 +1,56 @@
+#
+# Author:: Adam Edwards (<adamed@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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/exceptions'
+require 'chef/platform/query_helpers'
+require 'chef/win32/error' if Chef::Platform.windows?
+require 'chef/win32/api/system' if Chef::Platform.windows?
+
+class Chef
+  module Mixin
+    module WindowsEnvHelper
+
+      if Chef::Platform.windows?
+        include Chef::ReservedNames::Win32::API::System
+      end
+
+      #see: http://msdn.microsoft.com/en-us/library/ms682653%28VS.85%29.aspx
+      HWND_BROADCAST = 0xffff
+      WM_SETTINGCHANGE = 0x001A
+      SMTO_BLOCK = 0x0001
+      SMTO_ABORTIFHUNG = 0x0002
+      SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
+
+      def broadcast_env_change
+        flags = SMTO_BLOCK | SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG
+        SendMessageTimeoutA(HWND_BROADCAST, WM_SETTINGCHANGE, 0, FFI::MemoryPointer.from_string('Environment').address, flags, 5000, nil)
+      end
+
+      def expand_path(path)
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms724265%28v=vs.85%29.aspx
+        # Max size of env block on windows is 32k
+        buf = 0.chr * 32 * 1024
+        if ExpandEnvironmentStringsA(path, buf, buf.length) == 0
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        buf.strip
+      end
+    end
+  end
+end

data/lib/chef/node.rb

@@ -397,7 +397,7 @@ class Chef
       end
       index_hash["recipe"] = run_list.recipe_names if run_list.recipe_names.length > 0
       index_hash["role"] = run_list.role_names if run_list.role_names.length > 0
-      index_hash["run_list"] = run_list.run_list if run_list.run_list.length > 0
+      index_hash["run_list"] = run_list.run_list_items
       index_hash
     end
 
@@ -409,7 +409,7 @@ class Chef
       display["normal"]           = normal_attrs
       display["default"]          = attributes.combined_default
       display["override"]         = attributes.combined_override
-      display["run_list"]         = run_list.run_list
+      display["run_list"]         = run_list.run_list_items
       display
     end
 

data/lib/chef/node_map.rb

@@ -0,0 +1,146 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright (c) 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.
+#
+
+class Chef
+  class NodeMap
+
+    VALID_OPTS = [
+      :on_platform,
+      :on_platforms,
+      :platform,
+      :os,
+      :platform_family,
+    ]
+
+    DEPRECATED_OPTS = [
+      :on_platform,
+      :on_platforms,
+    ]
+
+    # Create a new NodeMap
+    #
+    def initialize
+      @map = {}
+    end
+
+    # Set a key/value pair on the map with a filter.  The filter must be true
+    # when applied to the node in order to retrieve the value.
+    #
+    # @param key [Object] Key to store
+    # @param value [Object] Value associated with the key
+    # @param filters [Hash] Node filter options to apply to key retrieval
+    # @yield [node] Arbitrary node filter as a block which takes a node argument
+    # @return [NodeMap] Returns self for possible chaining
+    #
+    def set(key, value, filters = {}, &block)
+      validate_filter!(filters)
+      deprecate_filter!(filters)
+      @map[key] ||= []
+      # we match on the first value we find, so we want to unshift so that the
+      # last setter wins
+      # FIXME: need a test for this behavior
+      @map[key].unshift({ filters: filters, block: block, value: value })
+      self
+    end
+
+    # Get a value from the NodeMap via applying the node to the filters that
+    # were set on the key.
+    #
+    # @param node [Chef::Node] The Chef::Node object for the run
+    # @param key [Object] Key to look up
+    # @return [Object] Value
+    #
+    def get(node, key)
+      # FIXME: real exception
+      raise "first argument must be a Chef::Node" unless node.is_a?(Chef::Node)
+      return nil unless @map.has_key?(key)
+      @map[key].each do |matcher|
+        if filters_match?(node, matcher[:filters]) &&
+          block_matches?(node, matcher[:block])
+          return matcher[:value]
+        end
+      end
+      nil
+    end
+
+    private
+
+    # only allow valid filter options
+    def validate_filter!(filters)
+      filters.each_key do |key|
+        # FIXME: real exception
+        raise "Bad key #{key} in Chef::NodeMap filter expression" unless VALID_OPTS.include?(key)
+      end
+    end
+
+    # warn on deprecated filter options
+    def deprecate_filter!(filters)
+      filters.each_key do |key|
+        Chef::Log.warn "The #{key} option to node_map has been deprecated" if DEPRECATED_OPTS.include?(key)
+      end
+    end
+
+    # @todo: this works fine, but is probably hard to understand
+    def negative_match(filter, param)
+      # We support strings prefaced by '!' to mean 'not'.  In particular, this is most useful
+      # for os matching on '!windows'.
+      negative_matches = filter.select { |f| f[0] == '!' }
+      return true if !negative_matches.empty? && negative_matches.include?('!' + param)
+
+      # We support the symbol :all to match everything, for backcompat, but this can and should
+      # simply be ommitted.
+      positive_matches = filter.reject { |f| f[0] == '!' || f == :all }
+      return true if !positive_matches.empty? && !positive_matches.include?(param)
+
+      # sorry double-negative: this means we pass this filter.
+      false
+    end
+
+    def filters_match?(node, filters)
+      return true if filters.empty?
+
+      # each filter is applied in turn.  if any fail, then it shortcuts and returns false.
+      # if it passes or does not exist it succeeds and continues on.  so multiple filters are
+      # effectively joined by 'and'.  all filters can be single strings, or arrays which are
+      # effectively joined by 'or'.
+
+      os_filter = [ filters[:os] ].flatten.compact
+      unless os_filter.empty?
+        return false if negative_match(os_filter, node[:os])
+      end
+
+      platform_family_filter = [ filters[:platform_family] ].flatten.compact
+      unless platform_family_filter.empty?
+        return false if negative_match(platform_family_filter, node[:platform_family])
+      end
+
+      # :on_platform and :on_platforms here are synonyms which are deprecated
+      platform_filter = [ filters[:platform] || filters[:on_platform] || filters[:on_platforms] ].flatten.compact
+      unless platform_filter.empty?
+        return false if negative_match(platform_filter, node[:platform])
+      end
+
+      return true
+    end
+
+    def block_matches?(node, block)
+      return true if block.nil?
+      block.call node
+    end
+  end
+end