chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/chef_fs/file_system/cookbook_dir.rb

@@ -27,12 +27,24 @@ class Chef
   module ChefFS
     module FileSystem
       class CookbookDir < BaseFSDir
-        def initialize(name, parent, versions = nil)
+        def initialize(name, parent, options = {})
           super(name, parent)
-          @versions = versions
+          @exists = options[:exists]
+          # If the name is apache2-1.0.0 and versioned_cookbooks is on, we know
+          # the actual cookbook_name and version.
+          if Chef::Config[:versioned_cookbooks]
+            if name =~ VALID_VERSIONED_COOKBOOK_NAME
+              @cookbook_name = $1
+              @version = $2
+            else
+              @exists = false
+            end
+          else
+            @cookbook_name = name
+          end
         end
 
-        attr_reader :versions
+        attr_reader :cookbook_name, :version
 
         COOKBOOK_SEGMENT_INFO = {
           :attributes => { :ruby_only => true },
@@ -46,12 +58,16 @@ class Chef
           :root_files => { }
         }
 
+        # See Erchef code
+        # https://github.com/opscode/chef_objects/blob/968a63344d38fd507f6ace05f73d53e9cd7fb043/src/chef_regex.erl#L94
+        VALID_VERSIONED_COOKBOOK_NAME = /^([.a-zA-Z0-9_-]+)-(\d+\.\d+\.\d+)$/
+
         def add_child(child)
           @children << child
         end
 
         def api_path
-          "#{parent.api_path}/#{name}/_latest"
+          "#{parent.api_path}/#{cookbook_name}/#{version || "_latest"}"
         end
 
         def child(name)
@@ -68,11 +84,8 @@ class Chef
 
         def can_have_child?(name, is_dir)
           # A cookbook's root may not have directories unless they are segment directories
-          if is_dir
-            return name != 'root_files' &&
-                   COOKBOOK_SEGMENT_INFO.keys.any? { |segment| segment.to_s == name }
-          end
-          true
+          return name != 'root_files' && COOKBOOK_SEGMENT_INFO.keys.include?(name.to_sym) if is_dir
+          return true
         end
 
         def children
@@ -100,6 +113,7 @@ class Chef
                 container.add_child(CookbookFile.new(parts[parts.length-1], container, segment_file))
               end
             end
+            @children = @children.sort_by { |c| c.name }
           end
           @children
         end
@@ -108,17 +122,32 @@ class Chef
           exists?
         end
 
-        def read
-          # This will only be called if dir? is false, which means exists? is false.
-          raise Chef::ChefFS::FileSystem::NotFoundError, path_for_printing
+        def delete(recurse)
+          if recurse
+            begin
+              rest.delete_rest(api_path)
+            rescue Timeout::Error => e
+              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "Timeout deleting: #{e}"
+            rescue Net::HTTPServerException
+              if $!.response.code == "404"
+                raise Chef::ChefFS::FileSystem::NotFoundError.new(self, $!)
+              else
+                raise Chef::ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "HTTP error deleting: #{e}"
+              end
+            end
+          else
+            raise NotFoundError.new(self) if !exists?
+            raise MustDeleteRecursivelyError.new(self), "#{path_for_printing} must be deleted recursively"
+          end
         end
 
+        # In versioned cookbook mode, actually check if the version exists
+        # Probably want to cache this.
         def exists?
-          if !@versions
-            child = parent.children.select { |child| child.name == name }.first
-            @versions = child.versions if child
+          if @exists.nil?
+            @exists = parent.children.any? { |child| child.name == name }
           end
-          !!@versions
+          @exists
         end
 
         def compare_to(other)
@@ -126,14 +155,16 @@ class Chef
             return [ !exists?, nil, nil ]
           end
           are_same = true
-          Chef::ChefFS::CommandLine::diff_entries(self, other, nil, :name_only) do
-            are_same = false
+          Chef::ChefFS::CommandLine::diff_entries(self, other, nil, :name_only).each do |type, old_entry, new_entry|
+            if [ :directory_to_file, :file_to_directory, :deleted, :added, :modified ].include?(type)
+              are_same = false
+            end
           end
           [ are_same, nil, nil ]
         end
 
-        def copy_from(other)
-          parent.upload_cookbook_from(other)
+        def copy_from(other, options = {})
+          parent.upload_cookbook_from(other, options)
         end
 
         def rest
@@ -147,7 +178,7 @@ class Chef
 
           # The negative (not found) response is cached
           if @could_not_get_chef_object
-            raise Chef::ChefFS::FileSystem::NotFoundError.new(@could_not_get_chef_object), "#{path_for_printing} not found"
+            raise Chef::ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
           end
 
           begin
@@ -159,26 +190,30 @@ class Chef
             old_retry_count = Chef::Config[:http_retry_count]
             begin
               Chef::Config[:http_retry_count] = 0
-              @chef_object ||= rest.get_rest(api_path)
+              @chef_object ||= Chef::CookbookVersion.json_create(Chef::ChefFS::RawRequest.raw_json(rest, api_path))
             ensure
               Chef::Config[:http_retry_count] = old_retry_count
             end
-          rescue Net::HTTPServerException
-            if $!.response.code == "404"
-              @could_not_get_chef_object = $!
-              raise Chef::ChefFS::FileSystem::NotFoundError.new(@could_not_get_chef_object), "#{path_for_printing} not found"
+
+          rescue Timeout::Error => e
+            raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "Timeout reading: #{e}"
+
+          rescue Net::HTTPServerException => e
+            if e.response.code == "404"
+              @could_not_get_chef_object = e
+              raise Chef::ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
             else
-              raise
+              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
             end
 
           # Chef bug http://tickets.opscode.com/browse/CHEF-3066 ... instead of 404 we get 500 right now.
           # Remove this when that bug is fixed.
-          rescue Net::HTTPFatalError
-            if $!.response.code == "500"
-              @could_not_get_chef_object = $!
-              raise Chef::ChefFS::FileSystem::NotFoundError.new(@could_not_get_chef_object), "#{path_for_printing} not found"
+          rescue Net::HTTPFatalError => e
+            if e.response.code == "500"
+              @could_not_get_chef_object = e
+              raise Chef::ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
             else
-              raise
+              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
             end
           end
         end

data/lib/chef/chef_fs/file_system/cookbook_file.rb

@@ -38,10 +38,21 @@ class Chef
           old_sign_on_redirect = rest.sign_on_redirect
           rest.sign_on_redirect = false
           begin
-            rest.get_rest(file[:url])
+            tmpfile = rest.get_rest(file[:url], true)
+          rescue Timeout::Error => e
+            raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "Timeout reading #{file[:url]}: #{e}"
+          rescue Net::HTTPServerException => e
+            raise Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "#{e.message} retrieving #{file[:url]}"
           ensure
             rest.sign_on_redirect = old_sign_on_redirect
           end
+
+          begin
+            tmpfile.open
+            tmpfile.read
+          ensure
+            tmpfile.close!
+          end
         end
 
         def rest
@@ -66,11 +77,7 @@ class Chef
         private
 
         def calc_checksum(value)
-          begin
-            Digest::MD5.hexdigest(value)
-          rescue Chef::ChefFS::FileSystem::NotFoundError
-            nil
-          end
+          Digest::MD5.hexdigest(value)
         end
       end
     end

data/lib/chef/chef_fs/file_system/cookbook_frozen_error.rb

@@ -0,0 +1,31 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 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/chef_fs/file_system/already_exists_error'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class CookbookFrozenError < AlreadyExistsError
+        def initialize(operation, entry, cause = nil)
+          super(operation, entry, cause)
+        end
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/file_system/cookbooks_acl_dir.rb

@@ -0,0 +1,41 @@
+#
+# Author:: John Keiser (<jkeiser@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/chef_fs/file_system/acl_dir'
+require 'chef/chef_fs/file_system/acl_entry'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class CookbooksAclDir < AclDir
+        # If versioned_cookbooks is on, the list of cookbooks will have versions
+        # in them.  But all versions of a cookbook have the same acl, so even if
+        # we have cookbooks/apache2-1.0.0 and cookbooks/apache2-1.1.2, we will
+        # only have one acl: acls/cookbooks/apache2.json.  Thus, the list of
+        # children of acls/cookbooks is a unique list of cookbook *names*.
+        def children
+          if @children.nil?
+            names = parent.parent.child(name).children.map { |child| "#{child.cookbook_name}.json" }
+            @children = names.uniq.map { |name| AclEntry.new(name, self, true) }
+          end
+          @children
+        end
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/file_system/cookbooks_dir.rb

@@ -18,6 +18,12 @@
 
 require 'chef/chef_fs/file_system/rest_list_dir'
 require 'chef/chef_fs/file_system/cookbook_dir'
+require 'chef/chef_fs/raw_request'
+require 'chef/chef_fs/file_system/operation_failed_error'
+require 'chef/chef_fs/file_system/cookbook_frozen_error'
+require 'chef/chef_fs/file_system/chef_repository_file_system_cookbook_dir'
+
+require 'tmpdir'
 
 class Chef
   module ChefFS
@@ -28,39 +34,114 @@ class Chef
         end
 
         def child(name)
-          result = @children.select { |child| child.name == name }.first if @children
-          result || CookbookDir.new(name, self)
+          if @children
+            result = self.children.select { |child| child.name == name }.first
+            if result
+              result
+            else
+              NonexistentFSObject.new(name, self)
+            end
+          else
+            CookbookDir.new(name, self)
+          end
         end
 
         def children
-          @children ||= rest.get_rest(api_path).map { |key, value| CookbookDir.new(key, self, value) }
+          @children ||= begin
+            if Chef::Config[:versioned_cookbooks]
+              result = []
+              Chef::ChefFS::RawRequest.raw_json(rest, "#{api_path}/?num_versions=all").each_pair do |cookbook_name, cookbooks|
+                cookbooks['versions'].each do |cookbook_version|
+                  result << CookbookDir.new("#{cookbook_name}-#{cookbook_version['version']}", self, :exists => true)
+                end
+              end
+            else
+              result = Chef::ChefFS::RawRequest.raw_json(rest, api_path).keys.map { |cookbook_name| CookbookDir.new(cookbook_name, self, :exists => true) }
+            end
+            result.sort_by(&:name)
+          end
         end
 
-        def create_child_from(other)
-          upload_cookbook_from(other)
+        def create_child_from(other, options = {})
+          upload_cookbook_from(other, options)
         end
 
-        def upload_cookbook_from(other)
-          other_cookbook_version = other.chef_object
-          # TODO this only works on the file system.  And it can't be broken into
-          # pieces.
-          begin
-            uploader = Chef::CookbookUploader.new(other_cookbook_version, other.parent.file_path)
-            uploader.upload_cookbooks
-          rescue Net::HTTPServerException => e
-            case e.response.code
-            when "409"
-              ui.error "Version #{other_cookbook_version.version} of cookbook #{other_cookbook_version.name} is frozen. Use --force to override."
-              Chef::Log.debug(e)
-              raise Exceptions::CookbookFrozen
-            else
-              raise
+        def upload_cookbook_from(other, options = {})
+          Chef::Config[:versioned_cookbooks] ? upload_versioned_cookbook(other, options) : upload_unversioned_cookbook(other, options)
+        rescue Timeout::Error => e
+          raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Timeout writing: #{e}"
+        rescue Net::HTTPServerException => e
+          case e.response.code
+          when "409"
+            raise Chef::ChefFS::FileSystem::CookbookFrozenError.new(:write, self, e), "Cookbook #{other.name} is frozen"
+          else
+            raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "HTTP error writing: #{e}"
+          end
+        rescue Chef::Exceptions::CookbookFrozen => e
+          raise Chef::ChefFS::FileSystem::CookbookFrozenError.new(:write, self, e), "Cookbook #{other.name} is frozen"
+        end
+
+        # Knife currently does not understand versioned cookbooks
+        # Cookbook Version uploader also requires a lot of refactoring
+        # to make this work. So instead, we make a temporary cookbook
+        # symlinking back to real cookbook, and upload the proxy.
+        def upload_versioned_cookbook(other, options)
+          cookbook_name = Chef::ChefFS::FileSystem::ChefRepositoryFileSystemCookbookDir.canonical_cookbook_name(other.name)
+
+          Dir.mktmpdir do |temp_cookbooks_path|
+            proxy_cookbook_path = "#{temp_cookbooks_path}/#{cookbook_name}"
+
+            # Make a symlink
+            File.symlink other.file_path, proxy_cookbook_path
+
+            # Instantiate a proxy loader using the temporary symlink
+            proxy_loader = Chef::Cookbook::CookbookVersionLoader.new(proxy_cookbook_path, other.parent.chefignore)
+            proxy_loader.load_cookbooks
+
+            cookbook_to_upload = proxy_loader.cookbook_version
+            cookbook_to_upload.freeze_version if options[:freeze]
+
+            # Instantiate a new uploader based on the proxy loader
+            uploader = Chef::CookbookUploader.new(cookbook_to_upload, proxy_cookbook_path, :force => options[:force], :rest => rest)
+
+            with_actual_cookbooks_dir(temp_cookbooks_path) do
+              upload_cookbook!(uploader)
             end
           end
         end
 
+        def upload_unversioned_cookbook(other, options)
+          cookbook_to_upload = other.chef_object
+          cookbook_to_upload.freeze_version if options[:freeze]
+          uploader = Chef::CookbookUploader.new(cookbook_to_upload, other.parent.file_path, :force => options[:force], :rest => rest)
+
+          with_actual_cookbooks_dir(other.parent.file_path) do
+            upload_cookbook!(uploader)
+          end
+        end
+
+        # Work around the fact that CookbookUploader doesn't understand chef_repo_path (yet)
+        def with_actual_cookbooks_dir(actual_cookbook_path)
+          old_cookbook_path = Chef::Config.cookbook_path
+          Chef::Config.cookbook_path = actual_cookbook_path if !Chef::Config.cookbook_path
+
+          yield
+        ensure
+          Chef::Config.cookbook_path = old_cookbook_path
+        end
+
+        def upload_cookbook!(uploader, options = {})
+          if uploader.respond_to?(:upload_cookbook)
+            uploader.upload_cookbook
+          else
+            uploader.upload_cookbooks
+          end
+        end
+
         def can_have_child?(name, is_dir)
-          is_dir
+          return false if !is_dir
+          return false if Chef::Config[:versioned_cookbooks] && name !~ Chef::ChefFS::FileSystem::CookbookDir::VALID_VERSIONED_COOKBOOK_NAME
+          return true
         end
       end
     end

data/lib/chef/chef_fs/file_system/data_bag_dir.rb

@@ -17,16 +17,16 @@
 #
 
 require 'chef/chef_fs/file_system/rest_list_dir'
-require 'chef/chef_fs/file_system/data_bag_item'
 require 'chef/chef_fs/file_system/not_found_error'
 require 'chef/chef_fs/file_system/must_delete_recursively_error'
+require 'chef/chef_fs/data_handler/data_bag_item_data_handler'
 
 class Chef
   module ChefFS
     module FileSystem
       class DataBagDir < RestListDir
         def initialize(name, parent, exists = nil)
-          super(name, parent)
+          super(name, parent, nil, Chef::ChefFS::DataHandler::DataBagItemDataHandler.new)
           @exists = nil
         end
 
@@ -36,7 +36,7 @@ class Chef
 
         def read
           # This will only be called if dir? is false, which means exists? is false.
-          raise Chef::ChefFS::FileSystem::NotFoundError, "#{path_for_printing} not found"
+          raise Chef::ChefFS::FileSystem::NotFoundError.new(self)
         end
 
         def exists?
@@ -46,29 +46,20 @@ class Chef
           @exists
         end
 
-        def create_child(name, file_contents)
-          json = Chef::JSONCompat.from_json(file_contents).to_hash
-          id = name[0,name.length-5]
-          if json.include?('id') && json['id'] != id
-            raise "ID in #{path_for_printing}/#{name} must be '#{id}' (is '#{json['id']}')"
-          end
-          rest.post_rest(api_path, json)
-          _make_child_entry(name, true)
-        end
-
-        def _make_child_entry(name, exists = nil)
-          DataBagItem.new(name, self, exists)
-        end
-
         def delete(recurse)
           if !recurse
-            raise Chef::ChefFS::FileSystem::MustDeleteRecursivelyError.new, "#{path_for_printing} must be deleted recursively"
+            raise NotFoundError.new(self) if !exists?
+            raise MustDeleteRecursivelyError.new(self), "#{path_for_printing} must be deleted recursively"
           end
           begin
             rest.delete_rest(api_path)
-          rescue Net::HTTPServerException
-            if $!.response.code == "404"
-              raise Chef::ChefFS::FileSystem::NotFoundError.new($!), "#{path_for_printing} not found"
+          rescue Timeout::Error => e
+            raise Chef::ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "Timeout deleting: #{e}"
+          rescue Net::HTTPServerException => e
+            if e.response.code == "404"
+              raise Chef::ChefFS::FileSystem::NotFoundError.new(self, e)
+            else
+              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "HTTP error deleting: #{e}"
             end
           end
         end