chef 12.6.0 → 12.7.2

data/lib/chef/chef_fs/file_system/{chef_repository_file_system_acls_dir.rb → chef_server/cookbook_artifact_dir.rb}

@@ -1,6 +1,6 @@
 #
-# Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2012-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,22 +16,23 @@
 # limitations under the License.
 #
 
-require 'chef/chef_fs/file_system/chef_repository_file_system_entry'
-require 'chef/chef_fs/file_system/acls_dir'
-require 'chef/chef_fs/data_handler/acl_data_handler'
+require "chef/chef_fs/file_system/chef_server/cookbook_dir"
 
 class Chef
   module ChefFS
     module FileSystem
-      class ChefRepositoryFileSystemAclsDir < ChefRepositoryFileSystemEntry
-        def initialize(name, parent, path = nil)
-          super(name, parent, path, Chef::ChefFS::DataHandler::AclDataHandler.new)
-        end
+      module ChefServer
+        class CookbookArtifactDir < CookbookDir
+          def initialize(name, parent, options = {})
+            super(name, parent)
+            @cookbook_name, dash, @version = name.rpartition("-")
+          end
 
-        def can_have_child?(name, is_dir)
-          is_dir ? Chef::ChefFS::FileSystem::AclsDir::ENTITY_TYPES.include?(name) : name == 'organization.json'
+          def copy_from(other, options = {})
+            raise OperationNotAllowedError.new(:write, self, nil, "cannot be updated: cookbook artifacts are immutable once uploaded")
+          end
         end
       end
     end
   end
-end
+end

data/lib/chef/chef_fs/file_system/chef_server/cookbook_artifacts_dir.rb

@@ -0,0 +1,102 @@
+#
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2012-2016, 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/chef_fs/file_system/chef_server/cookbooks_dir"
+require "chef/chef_fs/file_system/chef_server/cookbook_artifact_dir"
+
+class Chef
+  module ChefFS
+    module FileSystem
+      module ChefServer
+        #
+        # /cookbook_artifacts
+        #
+        # Example children of /cookbook_artifacts:
+        #
+        # - apache2-ab234098245908ddf324a
+        # - apache2-295387a9823745feff239
+        # - mysql-1a2b9e1298734dfe90444
+        #
+        class CookbookArtifactsDir < CookbooksDir
+
+          def make_child_entry(name)
+            result = @children.select { |child| child.name == name }.first if @children
+            result || CookbookArtifactDir.new(name, self)
+          end
+
+          def children
+            @children ||= begin
+              result = []
+              root.get_json("#{api_path}/?num_versions=all").each_pair do |cookbook_name, cookbooks|
+                cookbooks["versions"].each do |cookbook_version|
+                  result << CookbookArtifactDir.new("#{cookbook_name}-#{cookbook_version['identifier']}", self)
+                end
+              end
+              result.sort_by(&:name)
+            end
+          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_cookbook(other, options)
+            cookbook_name, dash, identifier = other.name.rpartition("-")
+
+            Dir.mktmpdir do |temp_cookbooks_path|
+              proxy_cookbook_path = "#{temp_cookbooks_path}/#{cookbook_name}"
+
+              # Make a symlink
+              file_class.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.identifier = identifier
+              cookbook_to_upload.freeze_version if options[:freeze]
+
+              # Instantiate a new uploader based on the proxy loader
+              uploader = Chef::CookbookUploader.new(cookbook_to_upload, force: options[:force], rest: root.chef_rest, policy_mode: true)
+
+              with_actual_cookbooks_dir(temp_cookbooks_path) do
+                uploader.upload_cookbooks
+              end
+
+              #
+              # When the temporary directory is being deleted on
+              # windows, the contents of the symlink under that
+              # directory is also deleted. So explicitly remove
+              # the symlink without removing the original contents if we
+              # are running on windows
+              #
+              if Chef::Platform.windows?
+                Dir.rmdir proxy_cookbook_path
+              end
+            end
+          end
+
+          def can_have_child?(name, is_dir)
+            is_dir && name.include?("-")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,222 @@
+#
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2012-2016, 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/chef_fs/command_line"
+require "chef/chef_fs/file_system/chef_server/rest_list_dir"
+require "chef/chef_fs/file_system/chef_server/cookbook_subdir"
+require "chef/chef_fs/file_system/chef_server/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
+      module ChefServer
+        # Unversioned cookbook.
+        #
+        #   /cookbooks/NAME
+        #
+        # Children look like:
+        #
+        # - metadata.rb
+        # - attributes/
+        # - libraries/
+        # - recipes/
+        #
+        class CookbookDir < BaseFSDir
+          def initialize(name, parent, options = {})
+            super(name, parent)
+            @exists = options[:exists]
+            @cookbook_name = name
+            @version = root.cookbook_version # nil unless --cookbook-version specified in download/diff
+          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 => {},
+          }
+
+          def add_child(child)
+            @children << child
+          end
+
+          def api_path
+            "#{parent.api_path}/#{cookbook_name}/#{version || "_latest"}"
+          end
+
+          def make_child_entry(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
+              children.select { |child| child.name == name }.first
+            rescue Chef::ChefFS::FileSystem::NotFoundError
+              nil
+            end
+          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(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.from_hash(root.get_json(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
+end

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

@@ -0,0 +1,84 @@
+#
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2012-2016, 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/chef_fs/file_system/base_fs_object"
+require "chef/http/simple"
+require "openssl"
+
+class Chef
+  module ChefFS
+    module FileSystem
+      module ChefServer
+        class CookbookFile < BaseFSObject
+          def initialize(name, parent, file)
+            super(name, parent)
+            @file = file
+          end
+
+          attr_reader :file
+
+          def checksum
+            file[:checksum]
+          end
+
+          def read
+            begin
+              tmpfile = rest.streaming_request(file[:url])
+            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]}")
+            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)
+            OpenSSL::Digest::MD5.hexdigest(value)
+          end
+        end
+      end
+    end
+  end
+end