chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/{shef → shell}/model_wrapper.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -19,7 +19,7 @@
 require 'chef/mixin/convert_to_class_name'
 require 'chef/mixin/language'
 
-module Shef
+module Shell
   class ModelWrapper
 
     include Chef::Mixin::ConvertToClassName

data/lib/chef/{shef/shef_rest.rb → shell/shell_rest.rb}

@@ -6,9 +6,9 @@
 # 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.
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-module Shef
-  class ShefREST < Chef::REST
+module Shell
+  class ShellREST < Chef::REST
 
     alias :get    :get_rest
     alias :put    :put_rest

data/lib/chef/{shef/shef_session.rb → shell/shell_session.rb}

@@ -29,8 +29,8 @@ require 'chef/formatters/base'
 require 'chef/formatters/doc'
 require 'chef/formatters/minimal'
 
-module Shef
-  class ShefSession
+module Shell
+  class ShellSession
     include Singleton
 
     def self.session_type(type=nil)
@@ -55,11 +55,11 @@ module Shef
         rebuild_node
         @node = client.node
         shorten_node_inspect
-        Shef::Extensions.extend_context_node(@node)
+        Shell::Extensions.extend_context_node(@node)
         rebuild_context
         node.consume_attributes(node_attributes) if node_attributes
         @recipe = Chef::Recipe.new(nil, nil, run_context)
-        Shef::Extensions.extend_context_recipe(@recipe)
+        Shell::Extensions.extend_context_recipe(@recipe)
         @node_built = true
       end
     end
@@ -86,7 +86,7 @@ module Shef
     end
 
     def save_node
-      raise "Not Supported! #{self.class.name} doesn't support #save_node, maybe you need to run shef in client mode?"
+      raise "Not Supported! #{self.class.name} doesn't support #save_node, maybe you need to run chef-shell in client mode?"
     end
 
     def rebuild_context
@@ -137,7 +137,7 @@ module Shef
 
   end
 
-  class StandAloneSession < ShefSession
+  class StandAloneSession < ShellSession
 
     session_type :standalone
 
@@ -151,7 +151,7 @@ module Shef
 
     def rebuild_node
       Chef::Config[:solo] = true
-      @client = Chef::Client.new(nil, Chef::Config[:shell_config])
+      @client = Chef::Client.new
       @client.run_ohai
       @client.load_node
       @client.build_node
@@ -159,7 +159,7 @@ module Shef
 
   end
 
-  class SoloSession < ShefSession
+  class SoloSession < ShellSession
 
     session_type :solo
 
@@ -170,8 +170,10 @@ module Shef
     def rebuild_context
       @run_status = Chef::RunStatus.new(@node, @events)
       Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, Chef::Config[:cookbook_path]) }
-      cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(Chef::Config[:cookbook_path]))
-      @run_context = Chef::RunContext.new(node, cookbook_collection, @events)
+      cl = Chef::CookbookLoader.new(Chef::Config[:cookbook_path])
+      cl.load_cookbooks
+      cookbook_collection = Chef::CookbookCollection.new(cl)
+      @run_context = Chef::RunContext.new(node, cookbook_collection, @events) 
       @run_context.load(Chef::RunList::RunListExpansionFromDisk.new("_default", []))
       @run_status.run_context = run_context
     end
@@ -181,7 +183,7 @@ module Shef
     def rebuild_node
       # Tell the client we're chef solo so it won't try to contact the server
       Chef::Config[:solo] = true
-      @client = Chef::Client.new(nil, Chef::Config[:shell_config])
+      @client = Chef::Client.new
       @client.run_ohai
       @client.load_node
       @client.build_node
@@ -212,7 +214,7 @@ module Shef
     def rebuild_node
       # Make sure the client knows this is not chef solo
       Chef::Config[:solo] = false
-      @client = Chef::Client.new(nil, Chef::Config[:shell_config])
+      @client = Chef::Client.new
       @client.run_ohai
       @client.register
       @client.load_node
@@ -277,7 +279,7 @@ module Shef
       puts
       Chef::Config[:doppelganger] = false
       @node_built = false
-      Shef.session
+      Shell.session
     end
 
     def rebuild_node

data/lib/chef/shell_out.rb

@@ -2,5 +2,12 @@ require 'mixlib/shellout'
 
 class Chef
   class ShellOut < Mixlib::ShellOut
+
+    def initialize(*args)
+      Chef::Log.warn("Chef::ShellOut is deprecated, please use Mixlib::ShellOut")
+      called_from = caller[0..3].inject("Called from:\n") {|msg, trace_line| msg << "  #{trace_line}\n" }
+      Chef::Log.warn(called_from)
+      super
+    end
   end
 end

data/lib/chef/user.rb

@@ -0,0 +1,182 @@
+#
+# Author:: Steven Danna (steve@opscode.com)
+# Copyright:: Copyright 2012 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/config'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/from_file'
+require 'chef/mash'
+require 'chef/json_compat'
+require 'chef/search/query'
+
+class Chef
+  class User
+
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+
+    def initialize
+      @name = ''
+      @public_key = nil
+      @private_key = nil
+      @password = nil
+      @admin = false
+    end
+
+    def name(arg=nil)
+      set_or_return(:name, arg,
+                    :regex => /^[a-z0-9\-_]+$/)
+    end
+
+    def admin(arg=nil)
+      set_or_return(:admin,
+                    arg, :kind_of => [TrueClass, FalseClass])
+    end
+
+    def public_key(arg=nil)
+      set_or_return(:public_key,
+                    arg, :kind_of => String)
+    end
+
+    def private_key(arg=nil)
+      set_or_return(:private_key,
+                    arg, :kind_of => String)
+    end
+
+    def password(arg=nil)
+      set_or_return(:password,
+                    arg, :kind_of => String)
+    end
+
+    def to_hash
+      result = {
+        "name" => @name,
+        "public_key" => @public_key,
+        "admin" => @admin
+      }
+      result["private_key"] = @private_key if @private_key
+      result["password"] = @password if @password
+      result
+    end
+
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+
+    def destroy
+      Chef::REST.new(Chef::Config[:chef_server_url]).delete_rest("users/#{@name}")
+    end
+
+    def create
+      payload = {:name => self.name, :admin => self.admin, :password => self.password }
+      payload[:public_key] = public_key if public_key
+      new_user =Chef::REST.new(Chef::Config[:chef_server_url]).post_rest("users", payload)
+      Chef::User.from_hash(self.to_hash.merge(new_user))
+    end
+
+    def update(new_key=false)
+      payload = {:name => name, :admin => admin}
+      payload[:private_key] = new_key if new_key
+      payload[:password] = password if password
+      updated_user = Chef::REST.new(Chef::Config[:chef_server_url]).put_rest("users/#{name}", payload)
+      Chef::User.from_hash(self.to_hash.merge(updated_user))
+    end
+
+    def save(new_key=false)
+      begin
+        create
+      rescue Net::HTTPServerException => e
+        if e.response.code == "409"
+          update(new_key)
+        else
+          raise e
+        end
+      end
+    end
+
+    def reregister
+      r = Chef::REST.new(Chef::Config[:chef_server_url])
+      reregistered_self = r.put_rest("users/#{name}", { :name => name, :admin => admin, :private_key => true })
+      private_key(reregistered_self["private_key"])
+      self
+    end
+
+    def to_s
+      "user[#{@name}]"
+    end
+
+    def inspect
+      "Chef::User name:'#{name}' admin:'#{admin.inspect}'" +
+      "public_key:'#{public_key}' private_key:#{private_key}"
+    end
+
+    # Class Methods
+
+    def self.from_hash(user_hash)
+      user = Chef::User.new
+      user.name user_hash['name']
+      user.private_key user_hash['private_key'] if user_hash.key?('private_key')
+      user.password user_hash['password'] if user_hash.key?('password')
+      user.public_key user_hash['public_key']
+      user.admin user_hash['admin']
+      user
+    end
+
+    def self.from_json(json)
+      Chef::User.from_hash(Chef::JSONCompat.from_json(json))
+    end
+
+    class << self
+      alias_method :json_create, :from_json
+    end
+
+    def self.list(inflate=false)
+      response = if inflate
+                   users = Chef::REST.new(Chef::Config[:chef_server_url]).get_rest('users')
+                   users.map do |name|
+                     Chef::User.load(name)
+                   end
+                 else
+                   Chef::REST.new(Chef::Config[:chef_server_url]).get_rest('users')
+                 end
+      if response.is_a? Array
+        transform_ohc_list_response(response)
+      else
+        response
+      end
+    end
+
+    def self.load(name)
+      response = Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("users/#{name}")
+      Chef::User.from_hash(response)
+    end
+
+    private
+
+    # Gross.  Transforms an API response in the form of:
+    # [ { "user" => { "username" => USERNAME }}, ...]
+    # into the form
+    # { "USERNAME" => "URI" }
+    def self.transform_ohc_list_response(response)
+      new_response = Hash.new
+      response.each do |u|
+        name = u['user']['username']
+        new_response[name] = Chef::Config[:chef_server_url] + "/users/#{name}"
+      end
+      new_response
+    end
+  end
+end

data/lib/chef/util/backup.rb

@@ -0,0 +1,84 @@
+#
+# Author:: Lamont Granquist (<lamont@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.
+#
+
+class Chef
+  class Util
+    class Backup
+      attr_reader :new_resource
+      attr_accessor :path
+
+      def initialize(new_resource, path = nil)
+        @new_resource = new_resource
+        @path = path.nil? ? new_resource.path : path
+      end
+
+      def backup!
+        if @new_resource.backup != false && @new_resource.backup > 0 && ::File.exist?(path)
+          do_backup
+          # Clean up after the number of backups
+          slice_number = @new_resource.backup
+          backup_files = sorted_backup_files
+          if backup_files.length >= @new_resource.backup
+            remainder = backup_files.slice(slice_number..-1)
+            remainder.each do |backup_to_delete|
+              delete_backup(backup_to_delete)
+            end
+          end
+        end
+      end
+
+      private
+
+      def backup_filename
+        @backup_filename ||= begin
+          time = Time.now
+          savetime = time.strftime("%Y%m%d%H%M%S")
+          backup_filename = "#{path}.chef-#{savetime}"
+          backup_filename = backup_filename.sub(/^([A-Za-z]:)/, "") #strip drive letter on Windows
+        end
+      end
+
+      def prefix
+        # if :file_backup_path is nil, we fallback to the old behavior of
+        # keeping the backup in the same directory. We also need to to_s it
+        # so we don't get a type error around implicit to_str conversions.
+        @prefix ||= Chef::Config[:file_backup_path].to_s
+      end
+
+      def backup_path
+        @backup_path ||= ::File.join(prefix, backup_filename)
+      end
+
+      def do_backup
+        FileUtils.mkdir_p(::File.dirname(backup_path)) if Chef::Config[:file_backup_path]
+        FileUtils.cp(path, backup_path, :preserve => true)
+        Chef::Log.info("#{@new_resource} backed up to #{backup_path}")
+      end
+
+      def delete_backup(backup_file)
+        FileUtils.rm(backup_file)
+        Chef::Log.info("#{@new_resource} removed backup at #{backup_file}")
+      end
+
+      def sorted_backup_files
+        Dir[::File.join(prefix, ".#{path}.chef-*")].sort { |a,b| b <=> a }
+      end
+    end
+  end
+end
+

data/lib/chef/util/diff.rb

@@ -0,0 +1,145 @@
+# Author:: Lamont Granquist (<lamont@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/mixin/shell_out'
+
+class Chef
+  class Util
+    class Diff
+      include Chef::Mixin::ShellOut
+
+      # @todo: to_a, to_s, to_json, inspect defs, accessors for @diff and @error
+      # @todo: move coercion to UTF-8 into to_json
+      # @todo: replace shellout to diff -u with diff-lcs gem
+
+      def for_output
+        # formatted output to a terminal uses arrays of strings and returns error strings
+        @diff.nil? ? [ @error ] : @diff
+      end
+
+      def for_reporting
+        # caller needs to ensure that new files aren't posted to resource reporting
+        return nil if @diff.nil?
+        @diff.join("\\n")
+      end
+
+      def use_tempfile_if_missing(file)
+        tempfile = nil
+        unless File.exists?(file)
+          Chef::Log.debug("file #{file} does not exist to diff against, using empty tempfile")
+          tempfile = Tempfile.new("chef-diff")
+          file = tempfile.path
+        end
+        yield file
+        unless tempfile.nil?
+          tempfile.close
+          tempfile.unlink
+        end
+      end
+
+      def diff(old_file, new_file)
+        use_tempfile_if_missing(old_file) do |old_file|
+          use_tempfile_if_missing(new_file) do |new_file|
+            @error = do_diff(old_file, new_file)
+          end
+        end
+      end
+
+      private
+
+      def do_diff(old_file, new_file)
+        if Chef::Config[:diff_disabled]
+          return "(diff output suppressed by config)"
+        end
+
+        diff_filesize_threshold = Chef::Config[:diff_filesize_threshold]
+        diff_output_threshold = Chef::Config[:diff_output_threshold]
+
+        if ::File.size(old_file) > diff_filesize_threshold || ::File.size(new_file) > diff_filesize_threshold
+          return "(file sizes exceed #{diff_filesize_threshold} bytes, diff output suppressed)"
+        end
+
+        # MacOSX(BSD?) diff will *sometimes* happily spit out nasty binary diffs
+        return "(current file is binary, diff output suppressed)" if is_binary?(old_file)
+        return "(new content is binary, diff output suppressed)" if is_binary?(new_file)
+
+        begin
+          # -u: Unified diff format
+          # LC_ALL: in ruby 1.9 we want to set nil which is a magic option to mixlib-shellout to
+          #         pass through the LC_ALL locale.  in ruby 1.8 we force to 7-bit 'C' locale
+          #         (which is the mixlib-shellout default for all rubies all the time).
+          Chef::Log.debug("running: diff -u #{old_file} #{new_file}")
+          locale = ( Object.const_defined? :Encoding ) ? nil : 'C'
+          result = shell_out("diff -u #{old_file} #{new_file}", :env => {'LC_ALL' => locale})
+
+        rescue Exception => e
+          # Should *not* receive this, but in some circumstances it seems that
+          # an exception can be thrown even using shell_out instead of shell_out!
+          return "Could not determine diff. Error: #{e.message}"
+        end
+
+        # diff will set a non-zero return code even when there's
+        # valid stdout results, if it encounters something unexpected
+        # So as long as we have output, we'll show it.
+        #
+        # Also on some platforms (Solaris) diff outputs a single line
+        # when there are no differences found. Look for this line
+        # before analyzing diff output.
+        if !result.stdout.empty? && result.stdout != "No differences encountered\n"
+          if result.stdout.length > diff_output_threshold
+            return "(long diff of over #{diff_output_threshold} characters, diff output suppressed)"
+          else
+            diff_str = result.stdout
+            if  Object.const_defined? :Encoding  # ruby >= 1.9
+              if ( diff_str.encoding == Encoding::ASCII_8BIT &&
+                diff_str.encoding != Encoding.default_external &&
+                RUBY_VERSION.to_f < 2.0 )
+                # @todo mixlib-shellout under ruby 1.9 hands back an ASCII-8BIT encoded string, which needs to
+                # be fixed to the default external encoding -- this should be moved into mixlib-shellout
+                diff_str = diff_str.force_encoding(Encoding.default_external)
+              end
+              diff_str.encode!('UTF-8', :invalid => :replace, :undef => :replace, :replace => '?')
+            end
+            @diff = diff_str.split("\n")
+            @diff.delete("\")
+            return "(diff available)"
+          end
+        elsif !result.stderr.empty?
+          return "Could not determine diff. Error: #{result.stderr}"
+        else
+          return "(no diff)"
+        end
+      end
+
+      def is_binary?(path)
+        File.open(path) do |file|
+          # XXX: this slurps into RAM, but we should have already checked our diff has a reasonable size
+          buff = file.read
+          buff = "" if buff.nil?
+          begin
+            return buff !~ /\A[\s[:print:]]*\z/m
+          rescue ArgumentError => e
+            return true if e.message =~ /invalid byte sequence/
+            raise
+          end
+        end
+      end
+
+    end
+  end
+end
+