chef 11.4.4 → 11.6.0.hotfix.1

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

@@ -0,0 +1,64 @@
+#
+# 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/base_fs_dir'
+require 'chef/chef_fs/file_system/acl_entry'
+require 'chef/chef_fs/file_system/operation_not_allowed_error'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class AclDir < BaseFSDir
+        def api_path
+          parent.parent.child(name).api_path
+        end
+
+        def child(name)
+          result = @children.select { |child| child.name == name }.first if @children
+          result ||= can_have_child?(name, false) ?
+                     AclEntry.new(name, self) : NonexistentFSObject.new(name, self)
+        end
+
+        def can_have_child?(name, is_dir)
+          name =~ /\.json$/ && !is_dir
+        end
+
+        def children
+          if @children.nil?
+            # Grab the ACTUAL children (/nodes, /containers, etc.) and get their names
+            names = parent.parent.child(name).children.map { |child| child.dir? ? "#{child.name}.json" : child.name }
+            @children = names.map { |name| AclEntry.new(name, self, true) }
+          end
+          @children
+        end
+
+        def create_child(name, file_contents)
+          raise OperationNotAllowedError.new(:create_child, self), "ACLs can only be updated, and can only be created when the corresponding object is created."
+        end
+
+        def data_handler
+          parent.data_handler
+        end
+
+        def rest
+          parent.rest
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+#
+# 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/rest_list_entry'
+require 'chef/chef_fs/file_system/not_found_error'
+require 'chef/chef_fs/file_system/operation_not_allowed_error'
+require 'chef/chef_fs/file_system/operation_failed_error'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class AclEntry < RestListEntry
+        PERMISSIONS = %w(create read update delete grant)
+
+        def api_path
+          "#{super}/_acl"
+        end
+
+        def delete(recurse)
+          raise Chef::ChefFS::FileSystem::OperationNotAllowedError.new(:delete, self, e), "ACLs cannot be deleted."
+        end
+
+        def write(file_contents)
+          # ACL writes are fun.
+          acls = data_handler.normalize(JSON.parse(file_contents, :create_additions => false), self)
+          PERMISSIONS.each do |permission|
+            begin
+              rest.put_rest("#{api_path}/#{permission}", { permission => acls[permission] })
+            rescue Timeout::Error => e
+              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Timeout writing: #{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(:write, self, e), "HTTP error writing: #{e}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+#
+# 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/base_fs_dir'
+require 'chef/chef_fs/file_system/acl_dir'
+require 'chef/chef_fs/file_system/cookbooks_acl_dir'
+require 'chef/chef_fs/file_system/acl_entry'
+require 'chef/chef_fs/data_handler/acl_data_handler'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class AclsDir < BaseFSDir
+        ENTITY_TYPES = %w(clients containers cookbooks data_bags environments groups nodes roles) # we don't read sandboxes, so we don't read their acls
+
+        def initialize(parent)
+          super('acls', parent)
+        end
+
+        def data_handler
+          @data_handler ||= Chef::ChefFS::DataHandler::AclDataHandler.new
+        end
+
+        def api_path
+          parent.api_path
+        end
+
+        def can_have_child?(name, is_dir)
+          is_dir ? ENTITY_TYPES.include(name) : name == 'organization.json'
+        end
+
+        def children
+          if @children.nil?
+            @children = ENTITY_TYPES.map do |entity_type|
+              case entity_type
+              when 'cookbooks'
+                CookbooksAclDir.new(entity_type, self)
+              else
+                AclDir.new(entity_type, self)
+              end
+            end
+            @children << AclEntry.new('organization.json', self, true) # the org acl is retrieved as GET /organizations/ORGNAME/ANYTHINGATALL/_acl
+          end
+          @children
+        end
+
+        def rest
+          parent.rest
+        end
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/file_system/already_exists_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/operation_failed_error'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class AlreadyExistsError < OperationFailedError
+        def initialize(operation, entry, cause = nil)
+          super(operation, entry, cause)
+        end
+      end
+    end
+  end
+end

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

@@ -17,6 +17,7 @@
 #
 
 require 'chef/chef_fs/path_utils'
+require 'chef/chef_fs/file_system/operation_not_allowed_error'
 
 class Chef
   module ChefFS
@@ -39,42 +40,6 @@ class Chef
         attr_reader :parent
         attr_reader :path
 
-        def root
-          parent ? parent.root : self
-        end
-
-        def path_for_printing
-          if parent
-            parent_path = parent.path_for_printing
-            if parent_path == '.'
-              name
-            else
-              Chef::ChefFS::PathUtils::join(parent.path_for_printing, name)
-            end
-          else
-            name
-          end
-        end
-
-        def dir?
-          false
-        end
-
-        def exists?
-          true
-        end
-
-        def child(name)
-          NonexistentFSObject.new(name, self)
-        end
-
-        # Override can_have_child? to report whether a given file *could* be added
-        # to this directory.  (Some directories can't have subdirs, some can only have .json
-        # files, etc.)
-        def can_have_child?(name, is_dir)
-          false
-        end
-
         # Override this if you have a special comparison algorithm that can tell
         # you whether this entry is the same as another--either a quicker or a
         # more reliable one.  Callers will use this to decide whether to upload,
@@ -109,13 +74,107 @@ class Chef
         #       are_same = (value == other_value)
         #     end
         def compare_to(other)
-          return nil
+          nil
+        end
+
+        # Override can_have_child? to report whether a given file *could* be added
+        # to this directory.  (Some directories can't have subdirs, some can only have .json
+        # files, etc.)
+        def can_have_child?(name, is_dir)
+          false
+        end
+
+        # Get a child of this entry with the given name.  This MUST always
+        # return a child, even if it is NonexistentFSObject.  Overriders should
+        # take caution not to do expensive network requests to get the list of
+        # children to fulfill this request, unless absolutely necessary here; it
+        # is intended as a quick way to traverse a hierarchy.
+        #
+        # For example, knife show /data_bags/x/y.json will call
+        # root.child('data_bags').child('x').child('y.json'), which can then
+        # directly perform a network request to retrieve the y.json data bag.  No
+        # network request was necessary to retrieve
+        def child(name)
+          NonexistentFSObject.new(name, self)
+        end
+
+        # Override children to report your *actual* list of children as an array.
+        def children
+          raise NotFoundError.new(self) if !exists?
+          []
+        end
+
+        # Expand this entry into a chef object (Chef::Role, ::Node, etc.)
+        def chef_object
+          raise NotFoundError.new(self) if !exists?
+          nil
+        end
+
+        # Create a child of this entry with the given name and contents.  If
+        # contents is nil, create a directory.
+        #
+        # NOTE: create_child_from is an optional method that can also be added to
+        # your entry class, and will be called without actually reading the
+        # file_contents.  This is used for knife upload /cookbooks/cookbookname.
+        def create_child(name, file_contents)
+          raise NotFoundError.new(self) if !exists?
+          raise OperationNotAllowedError.new(:create_child, self)
+        end
+
+        # Delete this item, possibly recursively.  Entries MUST NOT delete a
+        # directory unless recurse is true.
+        def delete(recurse)
+          raise NotFoundError.new(self) if !exists?
+          raise OperationNotAllowedError.new(:delete, self)
+        end
+
+        # Ask whether this entry is a directory.  If not, it is a file.
+        def dir?
+          false
+        end
+
+        # Ask whether this entry exists.
+        def exists?
+          true
+        end
+
+        # Printable path, generally used to distinguish paths in one root from
+        # paths in another.
+        def path_for_printing
+          if parent
+            parent_path = parent.path_for_printing
+            if parent_path == '.'
+              name
+            else
+              Chef::ChefFS::PathUtils::join(parent.path_for_printing, name)
+            end
+          else
+            name
+          end
+        end
+
+        def root
+          parent ? parent.root : self
+        end
+
+        # Read the contents of this file entry.
+        def read
+          raise NotFoundError.new(self) if !exists?
+          raise OperationNotAllowedError.new(:read, self)
+        end
+
+        # Write the contents of this file entry.
+        def write(file_contents)
+          raise NotFoundError.new(self) if !exists?
+          raise OperationNotAllowedError.new(:write, self)
         end
 
         # Important directory attributes: name, parent, path, root
         # Overridable attributes: dir?, child(name), path_for_printing
-        # Abstract: read, write, delete, children
-      end
+        # Abstract: read, write, delete, children, can_have_child?, create_child, compare_to
+      end # class BaseFsObject
     end
   end
 end
+
+require 'chef/chef_fs/file_system/nonexistent_fs_object'

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

@@ -0,0 +1,85 @@
+#
+# 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/chef_repository_file_system_cookbook_entry'
+require 'chef/chef_fs/file_system/cookbook_dir'
+require 'chef/cookbook/chefignore'
+require 'chef/cookbook/cookbook_version_loader'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class ChefRepositoryFileSystemCookbookDir < ChefRepositoryFileSystemCookbookEntry
+        def initialize(name, parent, file_path = nil)
+          super(name, parent, file_path)
+        end
+
+        def chef_object
+          begin
+            loader = Chef::Cookbook::CookbookVersionLoader.new(file_path, parent.chefignore)
+            # We need the canonical cookbook name if we are using versioned cookbooks, but we don't
+            # want to spend a lot of time adding code to the main Chef libraries
+            if Chef::Config[:versioned_cookbooks]
+              _canonical_name = canonical_cookbook_name(File.basename(file_path))
+              fail "When versioned_cookbooks mode is on, cookbook #{file_path} must match format <cookbook_name>-x.y.z"  unless _canonical_name
+
+              # KLUDGE: We shouldn't have to use instance_variable_set
+              loader.instance_variable_set(:@cookbook_name, _canonical_name)
+            end
+
+            loader.load_cookbooks
+            return loader.cookbook_version
+          rescue
+            Chef::Log.error("Could not read #{path_for_printing} into a Chef object: #{$!}")
+          end
+          nil
+        end
+
+        def children
+          Dir.entries(file_path).sort.
+              select { |child_name| can_have_child?(child_name, File.directory?(File.join(file_path, child_name))) }.
+              map do |child_name|
+                segment_info = CookbookDir::COOKBOOK_SEGMENT_INFO[child_name.to_sym] || {}
+                ChefRepositoryFileSystemCookbookEntry.new(child_name, self, nil, segment_info[:ruby_only], segment_info[:recursive])
+              end.
+              select { |entry| !(entry.dir? && entry.children.size == 0) }
+        end
+
+        def can_have_child?(name, is_dir)
+          if is_dir
+            # Only the given directories will be uploaded.
+            return CookbookDir::COOKBOOK_SEGMENT_INFO.keys.include?(name.to_sym) && name != 'root_files'
+          end
+
+          super(name, is_dir)
+        end
+
+        # Exposed as a class method so that it can be used elsewhere
+        def self.canonical_cookbook_name(entry_name)
+          name_match = Chef::ChefFS::FileSystem::CookbookDir::VALID_VERSIONED_COOKBOOK_NAME.match(entry_name)
+          return nil if name_match.nil?
+          return name_match[1]
+        end
+
+        def canonical_cookbook_name(entry_name)
+          self.class.canonical_cookbook_name(entry_name)
+        end
+      end
+    end
+  end
+end