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

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

@@ -0,0 +1,223 @@
+#
+# 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/rest_list_dir'
+require 'chef/chef_fs/file_system/cookbook_subdir'
+require 'chef/chef_fs/file_system/cookbook_file'
+require 'chef/chef_fs/file_system/not_found_error'
+require 'chef/cookbook_version'
+require 'chef/cookbook_uploader'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class CookbookDir < BaseFSDir
+        def initialize(name, parent, options = {})
+          super(name, parent)
+          @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 :cookbook_name, :version
+
+        COOKBOOK_SEGMENT_INFO = {
+          :attributes => { :ruby_only => true },
+          :definitions => { :ruby_only => true },
+          :recipes => { :ruby_only => true },
+          :libraries => { :ruby_only => true },
+          :templates => { :recursive => true },
+          :files => { :recursive => true },
+          :resources => { :ruby_only => true, :recursive => true },
+          :providers => { :ruby_only => true, :recursive => true },
+          :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}/#{cookbook_name}/#{version || "_latest"}"
+        end
+
+        def child(name)
+          # Since we're ignoring the rules and doing a network request here,
+          # we need to make sure we don't rethrow the exception.  (child(name)
+          # is not supposed to fail.)
+          begin
+            result = children.select { |child| child.name == name }.first
+            return result if result
+          rescue Chef::ChefFS::FileSystem::NotFoundError
+          end
+          return NonexistentFSObject.new(name, self)
+        end
+
+        def can_have_child?(name, is_dir)
+          # A cookbook's root may not have directories unless they are segment directories
+          return name != 'root_files' && COOKBOOK_SEGMENT_INFO.keys.include?(name.to_sym) if is_dir
+          return true
+        end
+
+        def children
+          if @children.nil?
+            @children = []
+            manifest = chef_object.manifest
+            COOKBOOK_SEGMENT_INFO.each do |segment, segment_info|
+              next unless manifest.has_key?(segment)
+
+              # Go through each file in the manifest for the segment, and
+              # add cookbook subdirs and files for it.
+              manifest[segment].each do |segment_file|
+                parts = segment_file[:path].split('/')
+                # Get or create the path to the file
+                container = self
+                parts[0,parts.length-1].each do |part|
+                  old_container = container
+                  container = old_container.children.select { |child| part == child.name }.first
+                  if !container
+                    container = CookbookSubdir.new(part, old_container, segment_info[:ruby_only], segment_info[:recursive])
+                    old_container.add_child(container)
+                  end
+                end
+                # Create the file itself
+                container.add_child(CookbookFile.new(parts[parts.length-1], container, segment_file))
+              end
+            end
+            @children = @children.sort_by { |c| c.name }
+          end
+          @children
+        end
+
+        def dir?
+          exists?
+        end
+
+        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 @exists.nil?
+            @exists = parent.children.any? { |child| child.name == name }
+          end
+          @exists
+        end
+
+        def compare_to(other)
+          if !other.dir?
+            return [ !exists?, nil, nil ]
+          end
+          are_same = true
+          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, options = {})
+          parent.upload_cookbook_from(other, options)
+        end
+
+        def rest
+          parent.rest
+        end
+
+        def chef_object
+          # We cheat and cache here, because it seems like a good idea to keep
+          # the cookbook view consistent with the directory structure.
+          return @chef_object if @chef_object
+
+          # The negative (not found) response is cached
+          if @could_not_get_chef_object
+            raise Chef::ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
+          end
+
+          begin
+            # We want to fail fast, for now, because of the 500 issue :/
+            # This will make things worse for parallelism, a little, because
+            # Chef::Config is global and this could affect other requests while
+            # this request is going on.  (We're not parallel yet, but we will be.)
+            # Chef bug http://tickets.opscode.com/browse/CHEF-3066
+            old_retry_count = Chef::Config[:http_retry_count]
+            begin
+              Chef::Config[:http_retry_count] = 0
+              @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 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 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 => 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 Chef::ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+#
+# 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/base_fs_object'
+require 'digest/md5'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class CookbookFile < BaseFSObject
+        def initialize(name, parent, file)
+          super(name, parent)
+          @file = file
+        end
+
+        attr_reader :file
+
+        def checksum
+          file[:checksum]
+        end
+
+        def read
+          old_sign_on_redirect = rest.sign_on_redirect
+          rest.sign_on_redirect = false
+          begin
+            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
+          parent.rest
+        end
+
+        def compare_to(other)
+          other_value = nil
+          if other.respond_to?(:checksum)
+            other_checksum = other.checksum
+          else
+            begin
+              other_value = other.read
+            rescue Chef::ChefFS::FileSystem::NotFoundError
+              return [ false, nil, :none ]
+            end
+            other_checksum = calc_checksum(other_value)
+          end
+          [ checksum == other_checksum, nil, other_value ]
+        end
+
+        private
+
+        def calc_checksum(value)
+          Digest::MD5.hexdigest(value)
+        end
+      end
+    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/cookbook_subdir.rb

@@ -0,0 +1,54 @@
+#
+# 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/base_fs_dir'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class CookbookSubdir < BaseFSDir
+        def initialize(name, parent, ruby_only, recursive)
+          super(name, parent)
+          @children = []
+          @ruby_only = ruby_only
+          @recursive = recursive
+        end
+
+        attr_reader :versions
+        attr_reader :children
+
+        def add_child(child)
+          @children << child
+        end
+
+        def can_have_child?(name, is_dir)
+          if is_dir
+            return false if !@recursive
+          else
+            return false if @ruby_only && name !~ /\.rb$/
+          end
+          true
+        end
+
+        def rest
+          parent.rest
+        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

@@ -0,0 +1,149 @@
+#
+# 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/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
+    module FileSystem
+      class CookbooksDir < RestListDir
+        def initialize(parent)
+          super("cookbooks", parent)
+        end
+
+        def child(name)
+          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 ||= 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, options = {})
+          upload_cookbook_from(other, options)
+        end
+
+        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)
+          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
+  end
+end