chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/lib/chef/knife/search.rb

@@ -53,7 +53,7 @@ class Chef
         :short => "-R INT",
         :long => "--rows INT",
         :description => "The number of rows to return",
-        :default => 1000,
+        :default => nil,
         :proc => lambda { |i| i.to_i }
 
       option :run_list,
@@ -92,9 +92,9 @@ class Chef
         result_count = 0
 
         search_args = Hash.new
-        search_args[:sort] = config[:sort]
-        search_args[:start] = config[:start]
-        search_args[:rows] = config[:rows]
+        search_args[:sort] = config[:sort] if config[:sort]
+        search_args[:start] = config[:start] if config[:start]
+        search_args[:rows] = config[:rows] if config[:rows]
         if config[:filter_result]
           search_args[:filter_result] = create_result_filter(config[:filter_result])
         elsif (not ui.config[:attribute].nil?) && (not ui.config[:attribute].empty?)

data/lib/chef/knife/serve.rb

@@ -4,6 +4,9 @@ require 'chef/local_mode'
 class Chef
   class Knife
     class Serve < Knife
+      
+      banner 'knife serve (options)'
+
       option :repo_mode,
         :long => '--repo-mode MODE',
         :description => "Specifies the local repository layout.  Values: static (only environments/roles/data_bags/cookbooks), everything (includes nodes/clients/users), hosted_everything (includes acls/groups/etc. for Enterprise/Hosted Chef).  Default: everything/hosted_everything"

data/lib/chef/knife/ssh.rb

@@ -313,7 +313,7 @@ class Chef
         puts
         puts "To exit interactive mode, use 'quit!'"
         puts
-        while 1
+        loop do
           command = read_line
           case command
           when 'quit!'

data/lib/chef/knife/ssl_check.rb

@@ -162,7 +162,7 @@ We are working on documentation for resolving common issues uncovered here.
 server's certificate. By default, the certificate is stored in the following
 location on the host where your chef-server runs:
 
-  /var/opt/chef-server/nginx/ca/SERVER_HOSTNAME.crt
+  /var/opt/opscode/nginx/ca/SERVER_HOSTNAME.crt
 
 Copy that file to your trusted_certs_dir (currently: #{configuration.trusted_certs_dir})
 using SSH/SCP or some other secure method, then re-run this command to confirm
@@ -191,7 +191,7 @@ configure chef to trust that server's certificate.
 By default, the certificate is stored in the following location on the host
 where your chef-server runs:
 
-  /var/opt/chef-server/nginx/ca/SERVER_HOSTNAME.crt
+  /var/opt/opscode/nginx/ca/SERVER_HOSTNAME.crt
 
 Copy that file to your trusted_certs_dir (currently: #{configuration.trusted_certs_dir})
 using SSH/SCP or some other secure method, then re-run this command to confirm

data/lib/chef/knife/ssl_fetch.rb

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require 'chef/knife/ssl_fetch'
+require 'chef/knife'
 require 'chef/config'
 
 class Chef
@@ -136,6 +136,19 @@ TRUST_TRUST
         remote_cert_chain.each do |cert|
           write_cert(cert)
         end
+      rescue OpenSSL::SSL::SSLError => e
+        # 'unknown protocol' usually means you tried to connect to a non-ssl
+        # service. We handle that specially here, any other error we let bubble
+        # up (probably a bug of some sort).
+        raise unless e.message.include?("unknown protocol")
+
+        ui.error("The service at the given URI (#{uri}) does not accept SSL connections")
+
+        if uri.scheme == "http"
+          https_uri = uri.to_s.sub(/^http/, 'https')
+          ui.error("Perhaps you meant to connect to '#{https_uri}'?")
+        end
+        exit 1
       end
 
 

data/lib/chef/log.rb

@@ -19,6 +19,7 @@
 
 require 'logger'
 require 'chef/monologger'
+require 'chef/exceptions'
 require 'mixlib/log'
 
 class Chef
@@ -34,6 +35,14 @@ class Chef
       end
     end
 
+    def self.deprecation(msg=nil, &block)
+      if Chef::Config[:treat_deprecation_warnings_as_errors]
+        error(msg, &block)
+        raise Chef::Exceptions::DeprecatedFeatureError.new(msg)
+      else
+        warn(msg, &block)
+      end
+    end
+
   end
 end
-

data/lib/chef/mixin/command.rb

@@ -82,7 +82,7 @@ class Chef
       end
 
       # works same as above, except that it returns stdout and stderr
-      # requirement => platforms like solaris 9,10 has wierd issues where
+      # requirement => platforms like solaris 9,10 has weird issues where
       # even in command failure the exit code is zero, so we need to lookup stderr.
       def run_command_and_return_stdout_stderr(args={})
         command_output = ""

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

@@ -18,11 +18,7 @@
 # limitations under the License.
 #
 
-if RUBY_VERSION =~ /^1\.8/
-  require 'win32/open3'
-else
-  require 'open3'
-end
+require 'open3'
 
 class Chef
   module Mixin

data/lib/chef/mixin/get_source_from_package.rb

@@ -29,6 +29,7 @@ class Chef
     module GetSourceFromPackage
       def initialize(new_resource, run_context)
         super
+        return if new_resource.package_name.is_a?(Array)
         # if we're passed something that looks like a filesystem path, with no source, use it
         #  - require at least one '/' in the path to avoid gem_package "foo" breaking if a file named 'foo' exists in the cwd
         if new_resource.source.nil? && new_resource.package_name.match(/#{::File::SEPARATOR}/) && ::File.exists?(new_resource.package_name)

data/lib/chef/mixin/params_validate.rb

@@ -42,8 +42,8 @@ class Chef
       #               method names.
       # :required:: Raise an exception if this parameter is missing. Valid values are true or false,
       #             by default, options are not required.
-      # :regex:: Match the value of the paramater against a regular expression.
-      # :equal_to:: Match the value of the paramater with ==.  An array means it can be equal to any
+      # :regex:: Match the value of the parameter against a regular expression.
+      # :equal_to:: Match the value of the parameter with ==.  An array means it can be equal to any
       #             of the values.
       def validate(opts, map)
         #--

data/lib/chef/mixin/securable.rb

@@ -111,13 +111,7 @@ class Chef
 
           # equivalent to something like:
           # def rights(permissions=nil, principals=nil, args_hash=nil)
-          define_method(name) do |*args|
-            # Ruby 1.8 compat: default the arguments
-            permissions = args.length >= 1 ? args[0] : nil
-            principals = args.length >= 2 ? args[1] : nil
-            args_hash = args.length >= 3 ? args[2] : nil
-            raise ArgumentError.new("wrong number of arguments (#{args.length} for 3)") if args.length >= 4
-
+          define_method(name) do |permissions=nil, principals=nil, args_hash=nil|
             rights = self.instance_variable_get("@#{name.to_s}".to_sym)
             unless permissions.nil?
               input = {

data/lib/chef/mixin/shell_out.rb

@@ -36,9 +36,15 @@ class Chef
           options[env_key] ||= {}
           options[env_key] = options[env_key].dup
           options[env_key]['LC_ALL'] ||= Chef::Config[:internal_locale] unless options[env_key].has_key?('LC_ALL')
+          options[env_key]['LANGUAGE'] ||= Chef::Config[:internal_locale] unless options[env_key].has_key?('LANGUAGE')
+          options[env_key]['LANG'] ||= Chef::Config[:internal_locale] unless options[env_key].has_key?('LANG')
           args << options
         else
-          args << { :environment => { 'LC_ALL' => Chef::Config[:internal_locale] } }
+          args << { :environment => {
+            'LC_ALL' => Chef::Config[:internal_locale],
+            'LANGUAGE' => Chef::Config[:internal_locale],
+            'LANG' => Chef::Config[:internal_locale],
+          } }
         end
 
         shell_out_command(*args)

data/lib/chef/mixin/template.rb

@@ -23,18 +23,6 @@ class Chef
   module Mixin
     module Template
 
-      # A compatibility wrapper around IO.binread so it works on Ruby 1.8.7.
-      # --
-      # Used in the TemplateContext class, but that method namespace is shared
-      # with user code, so we want to avoid adding methods there when possible.
-      def self.binread(file)
-        if IO.respond_to?(:binread)
-          IO.binread(file)
-        else
-          File.open(file, "rb") {|f| f.read }
-        end
-      end
-
       # == ChefContext
       # ChefContext was previously used to mix behavior into Erubis::Context so
       # that it would be available to templates. This behavior has now moved to
@@ -105,11 +93,11 @@ class Chef
           partial_context._extend_modules(@_extension_modules)
 
           template_location = @template_finder.find(partial_name, options)
-          _render_template(Mixin::Template.binread(template_location), partial_context)
+          _render_template(IO.binread(template_location), partial_context)
         end
 
         def render_template(template_location)
-          _render_template(Mixin::Template.binread(template_location), self)
+          _render_template(IO.binread(template_location), self)
         end
 
         def render_template_from_string(template)

data/lib/chef/mixin/why_run.rb

@@ -48,7 +48,7 @@ class Chef
         # block/proc that implements the action.
         def add_action(descriptions, &block)
           @actions << [descriptions, block]
-          if !Chef::Config[:why_run]
+          if (@resource.respond_to?(:is_guard_interpreter) && @resource.is_guard_interpreter) || !Chef::Config[:why_run]
             block.call
           end
           events.resource_update_applied(@resource, @action, descriptions)

data/lib/chef/monkey_patches/net_http.rb

@@ -42,6 +42,10 @@ if Net::HTTP.instance_methods.map {|m| m.to_s}.include?("proxy_uri")
     #    	from -e:1:in `<main>'
     #
     # https://bugs.ruby-lang.org/issues/9129
+    #
+    # NOTE: This should be fixed in Ruby 2.2.0, and backported to Ruby 2.0 and
+    # 2.1 (not yet released so the version/patchlevel required isn't known
+    # yet).
     Net::HTTP.new("::1", 80).proxy_uri
   rescue URI::InvalidURIError
     class Net::HTTP

data/lib/chef/monologger.rb

@@ -1,5 +1,4 @@
 require 'logger'
-
 require 'pp'
 
 #== MonoLogger
@@ -89,4 +88,3 @@ class MonoLogger < Logger
 
 
 end
-

data/lib/chef/node.rb

@@ -47,6 +47,8 @@ class Chef
 
     attr_accessor :recipe_list, :run_state, :override_runlist
 
+    attr_accessor :chef_server_rest
+
     # RunContext will set itself as run_context via this setter when
     # initialized. This is needed so DSL::IncludeAttribute (in particular,
     # #include_recipe) can access the run_context to determine if an attributes
@@ -62,7 +64,8 @@ class Chef
     include Chef::Mixin::ParamsValidate
 
     # Create a new Chef::Node object.
-    def initialize
+    def initialize(chef_server_rest: nil)
+      @chef_server_rest = chef_server_rest
       @name = nil
 
       @chef_environment = '_default'
@@ -80,7 +83,7 @@ class Chef
     end
 
     def chef_server_rest
-      Chef::REST.new(Chef::Config[:chef_server_url])
+      @chef_server_rest ||= Chef::REST.new(Chef::Config[:chef_server_url])
     end
 
     # Set the name of this Node, or return the current name.

data/lib/chef/node/attribute.rb

@@ -138,11 +138,9 @@ class Chef
        :values,
        :values_at,
        :zip].each do |delegated_method|
-         class_eval(<<-METHOD_DEFN)
-            def #{delegated_method}(*args, &block)
-              merged_attributes.send(:#{delegated_method}, *args, &block)
-            end
-         METHOD_DEFN
+         define_method(delegated_method) do |*args, &block|
+           merged_attributes.send(delegated_method, *args, &block)
+         end
        end
 
        # return the cookbook level default attribute component
@@ -253,7 +251,7 @@ class Chef
          if path.nil?
            @deep_merge_cache = {}
          else
-           deep_merge_cache.delete(path)
+           deep_merge_cache.delete(path.to_s)
          end
        end
 
@@ -436,12 +434,12 @@ class Chef
        end
 
        def [](key)
-         if deep_merge_cache.has_key?(key)
+         if deep_merge_cache.has_key?(key.to_s)
            # return the cache of the deep merged values by top-level key
-           deep_merge_cache[key]
+           deep_merge_cache[key.to_s]
          else
            # save all the work of computing node[key]
-           deep_merge_cache[key] = merged_attributes(key)
+           deep_merge_cache[key.to_s] = merged_attributes(key)
          end
        end
 
@@ -477,6 +475,10 @@ class Chef
          end
        end
 
+       def to_s
+         merged_attributes.to_s
+       end
+
        def inspect
          "#<#{self.class} " << (COMPONENTS + [:@merged_attributes, :@properties]).map{|iv|
            "#{iv}=#{instance_variable_get(iv).inspect}"

data/lib/chef/node/attribute_collections.rb

@@ -61,12 +61,10 @@ class Chef
       # also invalidate the cached merged_attributes on the root
       # Node::Attribute object.
       MUTATOR_METHODS.each do |mutator|
-        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
-          def #{mutator}(*args, &block)
-            root.reset_cache(root.top_level_breadcrumb)
-            super
-          end
-        METHOD_DEFN
+        define_method(mutator) do |*args, &block|
+          root.reset_cache(root.top_level_breadcrumb)
+          super(*args, &block)
+        end
       end
 
       attr_reader :root
@@ -126,12 +124,10 @@ class Chef
       # also invalidate the cached `merged_attributes` on the root Attribute
       # object.
       MUTATOR_METHODS.each do |mutator|
-        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
-          def #{mutator}(*args, &block)
-            root.reset_cache(root.top_level_breadcrumb)
-            super
-          end
-        METHOD_DEFN
+        define_method(mutator) do |*args, &block|
+          root.reset_cache(root.top_level_breadcrumb)
+          super(*args, &block)
+        end
       end
 
       def initialize(root, data={})

data/lib/chef/node/immutable_collections.rb

@@ -75,12 +75,9 @@ class Chef
       # Redefine all of the methods that mutate a Hash to raise an error when called.
       # This is the magic that makes this object "Immutable"
       DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
-        # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
-        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
-          def #{mutator_method_name}(*args, &block)
-            raise Exceptions::ImmutableAttributeModification
-          end
-        METHOD_DEFN
+        define_method(mutator_method_name) do |*args, &block|
+          raise Exceptions::ImmutableAttributeModification
+        end
       end
 
       # For elements like Fixnums, true, nil...
@@ -164,12 +161,9 @@ class Chef
       # Redefine all of the methods that mutate a Hash to raise an error when called.
       # This is the magic that makes this object "Immutable"
       DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
-        # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
-        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
-        def #{mutator_method_name}(*args, &block)
+        define_method(mutator_method_name) do |*args, &block|
           raise Exceptions::ImmutableAttributeModification
         end
-        METHOD_DEFN
       end
 
       def method_missing(symbol, *args)

data/lib/chef/org.rb

@@ -0,0 +1,148 @@
+#
+# Author:: Steven Danna (steve@opscode.com)
+# 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.
+#
+
+require 'chef/json_compat'
+require 'chef/mixin/params_validate'
+require 'chef/rest'
+
+class Chef
+  class Org
+
+    include Chef::Mixin::ParamsValidate
+
+    def initialize(name)
+      @name = name
+      @full_name = ''
+      # The Chef API returns the private key of the validator
+      # client on create
+      @private_key = nil
+      @guid = nil
+    end
+
+    def chef_rest
+      @chef_rest ||= Chef::REST.new(Chef::Config[:chef_server_root])
+    end
+
+    def name(arg=nil)
+      set_or_return(:name, arg,
+                    :regex => /^[a-z0-9\-_]+$/)
+    end
+
+    def full_name(arg=nil)
+      set_or_return(:full_name,
+                    arg, :kind_of => String)
+    end
+
+    def private_key(arg=nil)
+      set_or_return(:private_key,
+                    arg, :kind_of => String)
+    end
+
+    def guid(arg=nil)
+      set_or_return(:guid,
+                    arg, :kind_of => String)
+    end
+
+    def to_hash
+      result = {
+        "name" => @name,
+        "full_name" => @full_name
+      }
+      result["private_key"] = @private_key if @private_key
+      result["guid"] = @guid if @guid
+      result
+    end
+
+    def to_json(*a)
+      Chef::JSONCompat.to_json(to_hash, *a)
+    end
+
+    def create
+      payload = {:name => self.name, :full_name => self.full_name}
+      new_org = chef_rest.post_rest("organizations", payload)
+      Chef::Org.from_hash(self.to_hash.merge(new_org))
+    end
+
+    def update
+      payload = {:name => self.name, :full_name => self.full_name}
+      new_org = chef_rest.put_rest("organizations/#{name}", payload)
+      Chef::Org.from_hash(self.to_hash.merge(new_org))
+    end
+
+    def destroy
+      chef_rest.delete_rest("organizations/#{@name}")
+    end
+
+    def save
+      begin
+        create
+      rescue Net::HTTPServerException => e
+        if e.response.code == "409"
+          update
+        else
+          raise e
+        end
+      end
+    end
+
+    def associate_user(username)
+      request_body = {:user => username}
+      response = chef_rest.post_rest "organizations/#{@name}/association_requests", request_body
+      association_id = response["uri"].split("/").last
+      chef_rest.put_rest "users/#{username}/association_requests/#{association_id}", { :response => 'accept' }
+    end
+
+    def dissociate_user(username)
+      chef_rest.delete_rest "organizations/#{name}/users/#{username}"
+    end
+
+    # Class methods
+    def self.from_hash(org_hash)
+      org = Chef::Org.new(org_hash['name'])
+      org.full_name org_hash['full_name']
+      org.private_key org_hash['private_key'] if org_hash.key?('private_key')
+      org.guid org_hash['guid'] if org_hash.key?('guid')
+      org
+    end
+
+    def self.from_json(json)
+      Chef::Org.from_hash(Chef::JSONCompat.from_json(json))
+    end
+
+    class <<self
+      alias_method :json_create, :from_json
+    end
+
+    def self.load(org_name)
+      response =  Chef::REST.new(Chef::Config[:chef_server_root]).get_rest("organizations/#{org_name}")
+      Chef::Org.from_hash(response)
+    end
+
+    def self.list(inflate=false)
+      orgs = Chef::REST.new(Chef::Config[:chef_server_root]).get_rest('organizations')
+      if inflate
+        orgs.inject({}) do |org_map, (name, _url)|
+          org_map[name] = Chef::Org.load(name)
+          org_map
+        end
+      else
+        orgs
+      end
+    end
+  end
+end