chef 12.5.1-universal-mingw32 → 12.6.0-universal-mingw32

data/lib/chef/knife/cookbook_site_install.rb

@@ -142,7 +142,11 @@ class Chef
       def extract_cookbook(upstream_file, version)
         ui.info("Uncompressing #{@cookbook_name} version #{version}.")
         # FIXME: Detect if we have the bad tar from git on Windows: https://github.com/opscode/chef/issues/1753
-        shell_out!("tar zxvf #{convert_path upstream_file}", :cwd => @install_path)
+        extract_command="tar zxvf \"#{convert_path upstream_file}\"" 
+        if Chef::Platform.windows?
+          extract_command << " --force-local"
+        end
+        shell_out!(extract_command, :cwd => @install_path)
       end
 
       def clear_existing_files(cookbook_path)

data/lib/chef/knife/core/bootstrap_context.rb

@@ -40,7 +40,7 @@ class Chef
         end
 
         def bootstrap_environment
-          @chef_config[:environment]
+          @config[:environment]
         end
 
         def validation_key
@@ -129,6 +129,7 @@ CONFIG
           s = "#{client_path} -j /etc/chef/first-boot.json"
           s << ' -l debug' if @config[:verbosity] and @config[:verbosity] >= 2
           s << " -E #{bootstrap_environment}" unless bootstrap_environment.nil?
+          s << " --no-color" unless @config[:color]
           s
         end
 

data/lib/chef/knife/core/node_presenter.rb

@@ -125,7 +125,7 @@ ROLES
             summarized << <<-SUMMARY
 #{key('Recipes:')}     #{Array(node[:recipes]).join(', ')}
 #{key('Platform:')}    #{node[:platform]} #{node[:platform_version]}
-#{key('Tags:')}        #{Array(node[:tags]).join(', ')}
+#{key('Tags:')}        #{node.tags.join(', ')}
 SUMMARY
             if config[:medium_output] || config[:long_output]
               summarized +=<<-MORE

data/lib/chef/knife/ssh.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 
+require 'chef/mixin/shell_out'
 require 'chef/knife'
 
 class Chef
@@ -29,7 +30,6 @@ class Chef
         require 'readline'
         require 'chef/exceptions'
         require 'chef/search/query'
-        require 'chef/mixin/shell_out'
         require 'chef/mixin/command'
         require 'chef/util/path_helper'
         require 'mixlib/shellout'
@@ -72,7 +72,7 @@ class Chef
         :description => "The ssh password - will prompt if flag is specified but no password is given",
         # default to a value that can not be a password (boolean)
         # so we can effectively test if this parameter was specified
-        # without a vlaue
+        # without a value
         :default => false
 
       option :ssh_port,
@@ -94,8 +94,12 @@ class Chef
         :boolean => true
 
       option :identity_file,
-        :short => "-i IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication. [DEPRECATED] Use --ssh-identity-file instead."
+
+      option :ssh_identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--ssh-identity-file IDENTITY_FILE",
         :description => "The SSH identity file used for authentication"
 
       option :host_key_verify,
@@ -111,6 +115,12 @@ class Chef
         :boolean => true,
         :proc => Proc.new { :raise }
 
+      option :tmux_split,
+        :long => "--tmux-split",
+        :description => "Split tmux window.",
+        :boolean => true,
+        :default => false
+
       def session
         config[:on_error] ||= :skip
         ssh_error_handler = Proc.new do |server|
@@ -222,8 +232,8 @@ class Chef
         {}.tap do |opts|
           # Chef::Config[:knife][:ssh_user] is parsed in #configure_user and written to config[:ssh_user]
           opts[:user] = user || config[:ssh_user] || ssh_config[:user]
-          if config[:identity_file]
-            opts[:keys] = File.expand_path(config[:identity_file])
+          if config[:ssh_identity_file]
+            opts[:keys] = File.expand_path(config[:ssh_identity_file])
             opts[:keys_only] = true
           elsif config[:ssh_password]
             opts[:password] = config[:ssh_password]
@@ -386,7 +396,7 @@ class Chef
         window = 0
         session.servers_for.each do |server|
           tf.print("screen -t \"#{server.host}\" #{window} ssh ")
-          tf.print("-i #{config[:identity_file]} ") if config[:identity_file]
+          tf.print("-i #{config[:ssh_identity_file]} ") if config[:ssh_identity_file]
           server.user ? tf.puts("#{server.user}@#{server.host}") : tf.puts(server.host)
           window += 1
         end
@@ -396,7 +406,7 @@ class Chef
 
       def tmux
         ssh_dest = lambda do |server|
-          identity = "-i #{config[:identity_file]} " if config[:identity_file]
+          identity = "-i #{config[:ssh_identity_file]} " if config[:ssh_identity_file]
           prefix = server.user ? "#{server.user}@" : ""
           "'ssh #{identity}#{prefix}#{server.host}'"
         end
@@ -404,7 +414,11 @@ class Chef
         new_window_cmds = lambda do
           if session.servers_for.size > 1
             [""] + session.servers_for[1..-1].map do |server|
-              "new-window -a -n '#{server.host}' #{ssh_dest.call(server)}"
+              if config[:tmux_split]
+                "split-window #{ssh_dest.call(server)}; tmux select-layout tiled"
+              else
+                "new-window -a -n '#{server.host}' #{ssh_dest.call(server)}"
+              end
             end
           else
             []
@@ -459,15 +473,15 @@ class Chef
         end
         raise Chef::Exceptions::Exec, "no command found for cssh" unless cssh_cmd
 
-        # pass in the consolidated itentity file option to cssh(X)
-        if config[:identity_file]
-          cssh_cmd << " --ssh_args '-i #{File.expand_path(config[:identity_file])}'"
+        # pass in the consolidated identity file option to cssh(X)
+        if config[:ssh_identity_file]
+          cssh_cmd << " --ssh_args '-i #{File.expand_path(config[:ssh_identity_file])}'"
         end
 
         session.servers_for.each do |server|
           cssh_cmd << " #{server.user ? "#{server.user}@#{server.host}" : server.host}"
         end
-        Chef::Log.debug("starting cssh session with command: #{cssh_cmd}")
+        Chef::Log.debug("Starting cssh session with command: #{cssh_cmd}")
         exec(cssh_cmd)
       end
 
@@ -506,9 +520,9 @@ class Chef
         end
       end
 
-      def configure_identity_file
-        config[:identity_file] = get_stripped_unfrozen_value(config[:identity_file] ||
-                             Chef::Config[:knife][:ssh_identity_file])
+      def configure_ssh_identity_file
+        # config[:identity_file] is DEPRECATED in favor of :ssh_identity_file
+        config[:ssh_identity_file] = get_stripped_unfrozen_value(config[:ssh_identity_file] || config[:identity_file] || Chef::Config[:knife][:ssh_identity_file])
       end
 
       def extract_nested_value(data_structure, path_spec)
@@ -522,7 +536,7 @@ class Chef
 
         configure_user
         configure_password
-        configure_identity_file
+        configure_ssh_identity_file
         configure_gateway
         configure_session
 

data/lib/chef/knife/ssl_check.rb

@@ -29,6 +29,8 @@ class Chef
         require 'uri'
         require 'chef/http/ssl_policies'
         require 'openssl'
+        require 'chef/mixin/proxified_socket'
+        include Chef::Mixin::ProxifiedSocket
       end
 
       banner "knife ssl check [URL] (options)"
@@ -75,7 +77,7 @@ class Chef
 
       def verify_peer_socket
         @verify_peer_socket ||= begin
-          tcp_connection = TCPSocket.new(host, port)
+          tcp_connection = proxified_socket(host, port)
           ssl_client = OpenSSL::SSL::SSLSocket.new(tcp_connection, verify_peer_ssl_context)
           ssl_client.hostname = host
           ssl_client
@@ -93,7 +95,7 @@ class Chef
 
       def noverify_socket
         @noverify_socket ||= begin
-          tcp_connection = TCPSocket.new(host, port)
+          tcp_connection = proxified_socket(host, port)
           OpenSSL::SSL::SSLSocket.new(tcp_connection, noverify_peer_ssl_context)
         end
       end

data/lib/chef/knife/ssl_fetch.rb

@@ -28,6 +28,8 @@ class Chef
         require 'socket'
         require 'uri'
         require 'openssl'
+        require 'chef/mixin/proxified_socket'
+        include Chef::Mixin::ProxifiedSocket
       end
 
       banner "knife ssl fetch [URL] (options)"
@@ -71,7 +73,7 @@ class Chef
       end
 
       def remote_cert_chain
-        tcp_connection = TCPSocket.new(host, port)
+        tcp_connection = proxified_socket(host, port)
         shady_ssl_connection = OpenSSL::SSL::SSLSocket.new(tcp_connection, noverify_peer_ssl_context)
         shady_ssl_connection.connect
         shady_ssl_connection.peer_cert_chain
@@ -155,4 +157,3 @@ TRUST_TRUST
     end
   end
 end
-

data/lib/chef/knife/status.rb

@@ -44,7 +44,11 @@ class Chef
       option :hide_healthy,
         :short => "-H",
         :long => "--hide-healthy",
-        :description => "Hide nodes that have run chef in the last hour"
+        :description => "Hide nodes that have run chef in the last hour. [DEPRECATED] Use --hide-by-mins MINS instead"
+
+      option :hide_by_mins,
+        :long => "--hide-by-mins MINS",
+        :description => "Hide nodes that have run chef in the last MINS minutes"
 
       def append_to_query(term)
         @query << " AND " unless @query.empty?
@@ -68,12 +72,21 @@ class Chef
         append_to_query("chef_environment:#{config[:environment]}") if config[:environment]
 
         if config[:hide_healthy]
+          ui.warn("-H / --hide-healthy is deprecated. Use --hide-by-mins MINS instead")
           time = Time.now.to_i
           # AND NOT is not valid lucene syntax, so don't use append_to_query
           @query << " " unless @query.empty?
           @query << "NOT ohai_time:[#{(time - 60*60).to_s} TO #{time.to_s}]"
         end
 
+        if config[:hide_by_mins]
+          hidemins = config[:hide_by_mins].to_i
+          time = Time.now.to_i
+          # AND NOT is not valid lucene syntax, so don't use append_to_query
+          @query << " " unless @query.empty?
+          @query << "NOT ohai_time:[#{(time - hidemins*60).to_s} TO #{time.to_s}]"
+        end
+
         @query = @query.empty? ? "*:*" : @query
 
         all_nodes = []

data/lib/chef/log.rb

@@ -37,6 +37,20 @@ class Chef
       end
     end
 
+    #
+    # Get the location of the caller (from the recipe). Grabs the first caller
+    # that is *not* in the chef gem proper (allowing us to weed out internal
+    # calls and give the user a more useful perspective).
+    #
+    # @return [String] The location of the caller (file:line#) from caller(0..20), or nil if no non-chef caller is found.
+    #
+    def self.caller_location
+      # Pick the first caller that is *not* part of the Chef gem, that's the
+      # thing the user wrote.
+      chef_gem_path = File.expand_path("../..", __FILE__)
+      caller(0..20).select { |c| !c.start_with?(chef_gem_path) }.first
+    end
+
     def self.deprecation(msg=nil, location=caller(2..2)[0], &block)
       if msg
         msg << " at #{Array(location).join("\n")}"

data/lib/chef/mixin/get_source_from_package.rb

@@ -1,5 +1,5 @@
 # Author:: Lamont Granquist (<lamont@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright (c) 2008-2015 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,6 +27,12 @@
 class Chef
   module Mixin
     module GetSourceFromPackage
+      # FIXME:  this is some bad code that I wrote a long time ago.
+      #  - it does too much in the initializer
+      #  - it mutates the new_resource
+      #  - it does not support multipackage arrays
+      # this code is deprecated, check out the :use_package_names_for_source
+      # subclass directive instead
       def initialize(new_resource, run_context)
         super
         return if new_resource.package_name.is_a?(Array)
@@ -40,4 +46,3 @@ class Chef
     end
   end
 end
-

data/lib/chef/mixin/properties.rb

@@ -0,0 +1,302 @@
+require 'chef/delayed_evaluator'
+require 'chef/mixin/params_validate'
+require 'chef/property'
+
+class Chef
+  module Mixin
+    module Properties
+      module ClassMethods
+        #
+        # The list of properties defined on this resource.
+        #
+        # Everything defined with `property` is in this list.
+        #
+        # @param include_superclass [Boolean] `true` to include properties defined
+        #   on superclasses; `false` or `nil` to return the list of properties
+        #   directly on this class.
+        #
+        # @return [Hash<Symbol,Property>] The list of property names and types.
+        #
+        def properties(include_superclass=true)
+          if include_superclass
+            result = {}
+            ancestors.reverse_each { |c| result.merge!(c.properties(false)) if c.respond_to?(:properties) }
+            result
+          else
+            @properties ||= {}
+          end
+        end
+
+        #
+        # Create a property on this resource class.
+        #
+        # If a superclass has this property, or if this property has already been
+        # defined by this resource, this will *override* the previous value.
+        #
+        # @param name [Symbol] The name of the property.
+        # @param type [Object,Array<Object>] The type(s) of this property.
+        #   If present, this is prepended to the `is` validation option.
+        # @param options [Hash<Symbol,Object>] Validation options.
+        #   @option options [Object,Array] :is An object, or list of
+        #     objects, that must match the value using Ruby's `===` operator
+        #     (`options[:is].any? { |v| v === value }`).
+        #   @option options [Object,Array] :equal_to An object, or list
+        #     of objects, that must be equal to the value using Ruby's `==`
+        #     operator (`options[:is].any? { |v| v == value }`)
+        #   @option options [Regexp,Array<Regexp>] :regex An object, or
+        #     list of objects, that must match the value with `regex.match(value)`.
+        #   @option options [Class,Array<Class>] :kind_of A class, or
+        #     list of classes, that the value must be an instance of.
+        #   @option options [Hash<String,Proc>] :callbacks A hash of
+        #     messages -> procs, all of which match the value. The proc must
+        #     return a truthy or falsey value (true means it matches).
+        #   @option options [Symbol,Array<Symbol>] :respond_to A method
+        #     name, or list of method names, the value must respond to.
+        #   @option options [Symbol,Array<Symbol>] :cannot_be A property,
+        #     or a list of properties, that the value cannot have (such as `:nil` or
+        #     `:empty`). The method with a questionmark at the end is called on the
+        #     value (e.g. `value.empty?`). If the value does not have this method,
+        #     it is considered valid (i.e. if you don't respond to `empty?` we
+        #     assume you are not empty).
+        #   @option options [Proc] :coerce A proc which will be called to
+        #     transform the user input to canonical form. The value is passed in,
+        #     and the transformed value returned as output. Lazy values will *not*
+        #     be passed to this method until after they are evaluated. Called in the
+        #     context of the resource (meaning you can access other properties).
+        #   @option options [Boolean] :required `true` if this property
+        #     must be present; `false` otherwise. This is checked after the resource
+        #     is fully initialized.
+        #   @option options [Boolean] :name_property `true` if this
+        #     property defaults to the same value as `name`. Equivalent to
+        #     `default: lazy { name }`, except that #property_is_set? will
+        #     return `true` if the property is set *or* if `name` is set.
+        #   @option options [Boolean] :name_attribute Same as `name_property`.
+        #   @option options [Object] :default The value this property
+        #     will return if the user does not set one. If this is `lazy`, it will
+        #     be run in the context of the instance (and able to access other
+        #     properties).
+        #   @option options [Boolean] :desired_state `true` if this property is
+        #     part of desired state. Defaults to `true`.
+        #   @option options [Boolean] :identity `true` if this property
+        #     is part of object identity. Defaults to `false`.
+        #
+        # @example Bare property
+        #   property :x
+        #
+        # @example With just a type
+        #   property :x, String
+        #
+        # @example With just options
+        #   property :x, default: 'hi'
+        #
+        # @example With type and options
+        #   property :x, String, default: 'hi'
+        #
+        def property(name, type=NOT_PASSED, **options)
+          name = name.to_sym
+
+          options.each { |k,v| options[k.to_sym] = v if k.is_a?(String) }
+
+          options[:instance_variable_name] = :"@#{name}" if !options.has_key?(:instance_variable_name)
+          options.merge!(name: name, declared_in: self)
+
+          if type == NOT_PASSED
+            # If a type is not passed, the property derives from the
+            # superclass property (if any)
+            if properties.has_key?(name)
+              property = properties[name].derive(**options)
+            else
+              property = property_type(**options)
+            end
+
+          # If a Property is specified, derive a new one from that.
+          elsif type.is_a?(Property) || (type.is_a?(Class) && type <= Property)
+            property = type.derive(**options)
+
+          # If a primitive type was passed, combine it with "is"
+          else
+            if options[:is]
+              options[:is] = ([ type ] + [ options[:is] ]).flatten(1)
+            else
+              options[:is] = type
+            end
+            property = property_type(**options)
+          end
+
+          local_properties = properties(false)
+          local_properties[name] = property
+
+          property.emit_dsl
+        end
+
+        #
+        # Create a reusable property type that can be used in multiple properties
+        # in different resources.
+        #
+        # @param options [Hash<Symbol,Object>] Validation options. see #property for
+        #   the list of options.
+        #
+        # @example
+        #   property_type(default: 'hi')
+        #
+        def property_type(**options)
+          Property.derive(**options)
+        end
+
+        #
+        # Create a lazy value for assignment to a default value.
+        #
+        # @param block The block to run when the value is retrieved.
+        #
+        # @return [Chef::DelayedEvaluator] The lazy value
+        #
+        def lazy(&block)
+          DelayedEvaluator.new(&block)
+        end
+
+        #
+        # Get or set the list of desired state properties for this resource.
+        #
+        # State properties are properties that describe the desired state
+        # of the system, such as file permissions or ownership.
+        # In general, state properties are properties that could be populated by
+        # examining the state of the system (e.g., File.stat can tell you the
+        # permissions on an existing file). Contrarily, properties that are not
+        # "state properties" usually modify the way Chef itself behaves, for example
+        # by providing additional options for a package manager to use when
+        # installing a package.
+        #
+        # This list is used by the Chef client auditing system to extract
+        # information from resources to describe changes made to the system.
+        #
+        # This method is unnecessary when declaring properties with `property`;
+        # properties are added to state_properties by default, and can be turned off
+        # with `desired_state: false`.
+        #
+        # ```ruby
+        # property :x # part of desired state
+        # property :y, desired_state: false # not part of desired state
+        # ```
+        #
+        # @param names [Array<Symbol>] A list of property names to set as desired
+        #   state.
+        #
+        # @return [Array<Property>] All properties in desired state.
+        #
+        def state_properties(*names)
+          if !names.empty?
+            names = names.map { |name| name.to_sym }.uniq
+
+            local_properties = properties(false)
+            # Add new properties to the list.
+            names.each do |name|
+              property = properties[name]
+              if !property
+                self.property name, instance_variable_name: false, desired_state: true
+              elsif !property.desired_state?
+                self.property name, desired_state: true
+              end
+            end
+
+            # If state_attrs *excludes* something which is currently desired state,
+            # mark it as desired_state: false.
+            local_properties.each do |name,property|
+              if property.desired_state? && !names.include?(name)
+                self.property name, desired_state: false
+              end
+            end
+          end
+
+          properties.values.select { |property| property.desired_state? }
+        end
+
+        #
+        # Set the identity of this resource to a particular set of properties.
+        #
+        # This drives #identity, which returns data that uniquely refers to a given
+        # resource on the given node (in such a way that it can be correlated
+        # across Chef runs).
+        #
+        # This method is unnecessary when declaring properties with `property`;
+        # properties can be added to identity during declaration with
+        # `identity: true`.
+        #
+        # ```ruby
+        # property :x, identity: true # part of identity
+        # property :y # not part of identity
+        # ```
+        #
+        # If no properties are marked as identity, "name" is considered the identity.
+        #
+        # @param names [Array<Symbol>] A list of property names to set as the identity.
+        #
+        # @return [Array<Property>] All identity properties.
+        #
+        def identity_properties(*names)
+          if !names.empty?
+            names = names.map { |name| name.to_sym }
+
+            # Add or change properties that are not part of the identity.
+            names.each do |name|
+              property = properties[name]
+              if !property
+                self.property name, instance_variable_name: false, identity: true
+              elsif !property.identity?
+                self.property name, identity: true
+              end
+            end
+
+            # If identity_properties *excludes* something which is currently part of
+            # the identity, mark it as identity: false.
+            properties.each do |name,property|
+              if property.identity? && !names.include?(name)
+
+                self.property name, identity: false
+              end
+            end
+          end
+
+          result = properties.values.select { |property| property.identity? }
+          result = [ properties[:name] ] if result.empty?
+          result
+        end
+
+        def included(other)
+          other.extend ClassMethods
+        end
+      end
+
+      def self.included(other)
+        other.extend ClassMethods
+      end
+
+      include Chef::Mixin::ParamsValidate
+
+      #
+      # Whether this property has been set (or whether it has a default that has
+      # been retrieved).
+      #
+      # @param name [Symbol] The name of the property.
+      # @return [Boolean] `true` if the property has been set.
+      #
+      def property_is_set?(name)
+        property = self.class.properties[name.to_sym]
+        raise ArgumentError, "Property #{name} is not defined in class #{self}" if !property
+        property.is_set?(self)
+      end
+
+      #
+      # Clear this property as if it had never been set. It will thereafter return
+      # the default.
+      # been retrieved).
+      #
+      # @param name [Symbol] The name of the property.
+      #
+      def reset_property(name)
+        property = self.class.properties[name.to_sym]
+        raise ArgumentError, "Property #{name} is not defined in class #{self}" if !property
+        property.reset(self)
+      end
+    end
+  end
+end