chef 11.4.4 → 11.6.0.hotfix.1

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

@@ -0,0 +1,71 @@
+#
+# 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_entry'
+require 'chef/chef_fs/file_system/chef_repository_file_system_cookbooks_dir'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class ChefRepositoryFileSystemCookbookEntry < ChefRepositoryFileSystemEntry
+        def initialize(name, parent, file_path = nil, ruby_only = false, recursive = false)
+          super(name, parent, file_path)
+          @ruby_only = ruby_only
+          @recursive = recursive
+        end
+
+        attr_reader :ruby_only
+        attr_reader :recursive
+
+        def children
+          Dir.entries(file_path).sort.
+              select { |child_name| can_have_child?(child_name, File.directory?(File.join(file_path, child_name))) }.
+              map { |child_name| ChefRepositoryFileSystemCookbookEntry.new(child_name, self, nil, ruby_only, recursive) }.
+              select { |entry| !(entry.dir? && entry.children.size == 0) }
+        end
+
+        def can_have_child?(name, is_dir)
+          if is_dir
+            return recursive && name != '.' && name != '..'
+          elsif ruby_only
+            return false if name[-3..-1] != '.rb'
+          end
+
+          # Check chefignore
+          ignorer = parent
+          begin
+            if ignorer.is_a?(ChefRepositoryFileSystemCookbooksDir)
+              # Grab the path from entry to child
+              path_to_child = name
+              child = self
+              while child.parent != ignorer
+                path_to_child = PathUtils.join(child.name, path_to_child)
+                child = child.parent
+              end
+              # Check whether that relative path is ignored
+              return !ignorer.chefignore || !ignorer.chefignore.ignored?(path_to_child)
+            end
+            ignorer = ignorer.parent
+          end while ignorer
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+#
+# 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_entry'
+require 'chef/chef_fs/file_system/chef_repository_file_system_cookbook_dir'
+require 'chef/cookbook/chefignore'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class ChefRepositoryFileSystemCookbooksDir < ChefRepositoryFileSystemEntry
+        def initialize(name, parent, file_path)
+          super(name, parent, file_path)
+          @chefignore = Chef::Cookbook::Chefignore.new(self.file_path)
+        end
+
+        attr_reader :chefignore
+
+        def children
+          Dir.entries(file_path).sort.
+              select { |child_name| can_have_child?(child_name, File.directory?(File.join(file_path, child_name))) }.
+              map { |child_name| ChefRepositoryFileSystemCookbookDir.new(child_name, self) }.
+              select do |entry|
+                # empty cookbooks and cookbook directories are ignored
+                if entry.children.size == 0
+                  Chef::Log.warn("Cookbook '#{entry.name}' is empty or entirely chefignored at #{entry.path_for_printing}")
+                  false
+                else
+                  true
+                end
+              end
+        end
+
+        def can_have_child?(name, is_dir)
+          is_dir && !name.start_with?('.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+#
+# 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_entry'
+require 'chef/chef_fs/data_handler/data_bag_item_data_handler'
+
+class Chef
+  module ChefFS
+    module FileSystem
+      class ChefRepositoryFileSystemDataBagsDir < ChefRepositoryFileSystemEntry
+        def initialize(name, parent, path = nil)
+          super(name, parent, path, Chef::ChefFS::DataHandler::DataBagItemDataHandler.new)
+        end
+
+        def can_have_child?(name, is_dir)
+          is_dir && !name.start_with?('.')
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 #
 # Author:: John Keiser (<jkeiser@opscode.com>)
+# Author:: Ho-Sheng Hsiao (<hosh@opscode.com>)
 # Copyright:: Copyright (c) 2012 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -17,90 +18,40 @@
 #
 
 require 'chef/chef_fs/file_system/file_system_entry'
-require 'chef/cookbook/chefignore'
-require 'chef/cookbook/cookbook_version_loader'
-require 'chef/node'
-require 'chef/role'
-require 'chef/environment'
-require 'chef/data_bag_item'
-require 'chef/client'
 
 class Chef
   module ChefFS
     module FileSystem
       # ChefRepositoryFileSystemEntry works just like FileSystemEntry,
-      # except it pretends files in /cookbooks/chefignore don't exist
-      # and it can inflate Chef objects
+      # except can inflate Chef objects
       class ChefRepositoryFileSystemEntry < FileSystemEntry
-        def initialize(name, parent, file_path = nil)
+        def initialize(name, parent, file_path = nil, data_handler = nil)
           super(name, parent, file_path)
-          # Load /cookbooks/chefignore
-          if name == "cookbooks" && path == "/cookbooks" # We check name first because it's a faster fail than path
-            @chefignore = Chef::Cookbook::Chefignore.new(self.file_path)
-          # If we are a cookbook or a cookbook subdirectory, empty directories
-          # underneath us are ignored (since they cannot be uploaded)
-          elsif parent && parent.name === "cookbooks" && parent.path == "/cookbooks"
-            @ignore_empty_directories = true
-          elsif parent && parent.ignore_empty_directories?
-            @ignore_empty_directories = true
-          end
+          @data_handler = data_handler
         end
 
-        attr_reader :chefignore
-
-        def ignore_empty_directories?
-          @ignore_empty_directories
+        def data_handler
+          @data_handler || parent.data_handler
         end
 
         def chef_object
           begin
-            if parent.path == "/cookbooks"
-              loader = Chef::Cookbook::CookbookVersionLoader.new(file_path, parent.chefignore)
-              loader.load_cookbooks
-              return loader.cookbook_version
-            end
-
-            # Otherwise the information to inflate the object, is in the file (json_class).
-            return Chef::JSONCompat.from_json(read)
+            return data_handler.chef_object(JSON.parse(read, :create_additions => false))
           rescue
             Chef::Log.error("Could not read #{path_for_printing} into a Chef object: #{$!}")
           end
           nil
         end
 
-        def children
-          @children ||= Dir.entries(file_path).select { |entry| entry != '.' && entry != '..' && !ignored?(entry) }.
-                                               map { |entry| ChefRepositoryFileSystemEntry.new(entry, self) }
+        def can_have_child?(name, is_dir)
+          !is_dir && name[-5..-1] == '.json'
         end
 
-        attr_reader :chefignore
-
-        private
-
-        def ignored?(child_name)
-          # empty directories inside a cookbook are ignored
-          if ignore_empty_directories?
-            child_path = PathUtils.join(file_path, child_name)
-            if File.directory?(child_path) && Dir.entries(child_path) == [ '.', '..' ]
-              return true
-            end
-          end
-
-          ignorer = self
-          begin
-            if ignorer.chefignore
-              # Grab the path from entry to child
-              path_to_child = child_name
-              child = self
-              while child != ignorer
-                path_to_child = PathUtils.join(child.name, path_to_child)
-                child = child.parent
-              end
-              # Check whether that relative path is ignored
-              return ignorer.chefignore.ignored?(path_to_child)
-            end
-            ignorer = ignorer.parent
-          end while ignorer
+        def children
+          # Except cookbooks and data bag dirs, all things must be json files
+          Dir.entries(file_path).sort.
+              select { |child_name| can_have_child?(child_name, File.directory?(File.join(file_path, child_name))) }.
+              map { |child_name| ChefRepositoryFileSystemEntry.new(child_name, self) }
         end
 
       end

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

@@ -16,14 +16,104 @@
 # limitations under the License.
 #
 
+require 'chef/chef_fs/file_system/base_fs_dir'
 require 'chef/chef_fs/file_system/chef_repository_file_system_entry'
+require 'chef/chef_fs/file_system/chef_repository_file_system_cookbooks_dir'
+require 'chef/chef_fs/file_system/chef_repository_file_system_data_bags_dir'
+require 'chef/chef_fs/file_system/multiplexed_dir'
+require 'chef/chef_fs/data_handler/client_data_handler'
+require 'chef/chef_fs/data_handler/environment_data_handler'
+require 'chef/chef_fs/data_handler/node_data_handler'
+require 'chef/chef_fs/data_handler/role_data_handler'
+require 'chef/chef_fs/data_handler/user_data_handler'
+require 'chef/chef_fs/data_handler/group_data_handler'
+require 'chef/chef_fs/data_handler/container_data_handler'
+require 'chef/chef_fs/data_handler/acl_data_handler'
 
 class Chef
   module ChefFS
     module FileSystem
-      class ChefRepositoryFileSystemRootDir < ChefRepositoryFileSystemEntry
-        def initialize(file_path)
-          super("", nil, file_path)
+      class ChefRepositoryFileSystemRootDir < BaseFSDir
+        def initialize(child_paths)
+          super("", nil)
+          @child_paths = child_paths
+        end
+
+        attr_reader :child_paths
+
+        def children
+          @children ||= child_paths.keys.sort.map { |name| make_child_entry(name) }.select { |child| !child.nil? }
+        end
+
+        def can_have_child?(name, is_dir)
+          child_paths.has_key?(name) && is_dir
+        end
+
+        def create_child(name, file_contents = nil)
+          child_paths[name].each do |path|
+            Dir.mkdir(path)
+          end
+          make_child_entry(name)
+        end
+
+        def json_class
+          nil
+        end
+
+        # Used to print out the filesystem
+        def fs_description
+          repo_path = File.dirname(child_paths['cookbooks'][0])
+          result = "repository at #{repo_path}\n"
+          if Chef::Config[:versioned_cookbooks]
+            result << "  Multiple versions per cookbook\n"
+          else
+            result << "  One version per cookbook\n"
+          end
+          child_paths.each_pair do |name, paths|
+            if paths.any? { |path| File.dirname(path) != repo_path }
+              result << "  #{name} at #{paths.join(', ')}\n"
+            end
+          end
+          result
+        end
+
+        private
+
+        def make_child_entry(name)
+          paths = child_paths[name].select do |path|
+            File.exists?(path)
+          end
+          if paths.size == 0
+            return nil
+          end
+          if name == 'cookbooks'
+            dirs = paths.map { |path| ChefRepositoryFileSystemCookbooksDir.new(name, self, path) }
+          elsif name == 'data_bags'
+            dirs = paths.map { |path| ChefRepositoryFileSystemDataBagsDir.new(name, self, path) }
+          else
+            data_handler = case name
+              when 'clients'
+                Chef::ChefFS::DataHandler::ClientDataHandler.new
+              when 'environments'
+                Chef::ChefFS::DataHandler::EnvironmentDataHandler.new
+              when 'nodes'
+                Chef::ChefFS::DataHandler::NodeDataHandler.new
+              when 'roles'
+                Chef::ChefFS::DataHandler::RoleDataHandler.new
+              when 'users'
+                Chef::ChefFS::DataHandler::UserDataHandler.new
+              when 'groups'
+                Chef::ChefFS::DataHandler::GroupDataHandler.new
+              when 'containers'
+                Chef::ChefFS::DataHandler::ContainerDataHandler.new
+              when 'acls'
+                Chef::ChefFS::DataHandler::AclDataHandler.new
+              else
+                raise "Unknown top level path #{name}"
+              end
+            dirs = paths.map { |path| ChefRepositoryFileSystemEntry.new(name, self, path, data_handler) }
+          end
+          MultiplexedDir.new(dirs)
         end
       end
     end

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

@@ -16,23 +16,31 @@
 # limitations under the License.
 #
 
+require 'chef/chef_fs/file_system/acls_dir'
 require 'chef/chef_fs/file_system/base_fs_dir'
 require 'chef/chef_fs/file_system/rest_list_dir'
 require 'chef/chef_fs/file_system/cookbooks_dir'
 require 'chef/chef_fs/file_system/data_bags_dir'
 require 'chef/chef_fs/file_system/nodes_dir'
+require 'chef/chef_fs/file_system/environments_dir'
+require 'chef/rest'
+require 'chef/chef_fs/data_handler/client_data_handler'
+require 'chef/chef_fs/data_handler/role_data_handler'
+require 'chef/chef_fs/data_handler/user_data_handler'
+require 'chef/chef_fs/data_handler/group_data_handler'
+require 'chef/chef_fs/data_handler/container_data_handler'
 
 class Chef
   module ChefFS
     module FileSystem
       class ChefServerRootDir < BaseFSDir
-        def initialize(root_name, chef_config, repo_mode)
+        def initialize(root_name, chef_config)
           super("", nil)
           @chef_server_url = chef_config[:chef_server_url]
           @chef_username = chef_config[:node_name]
           @chef_private_key = chef_config[:client_key]
           @environment = chef_config[:environment]
-          @repo_mode = repo_mode
+          @repo_mode = chef_config[:repo_mode]
           @root_name = root_name
         end
 
@@ -42,6 +50,10 @@ class Chef
         attr_reader :environment
         attr_reader :repo_mode
 
+        def fs_description
+          "Chef server at #{chef_server_url} (user #{chef_username}), repo_mode = #{repo_mode}"
+        end
+
         def rest
           Chef::REST.new(chef_server_url, chef_username, chef_private_key)
         end
@@ -58,26 +70,40 @@ class Chef
           is_dir && children.any? { |child| child.name == name }
         end
 
+        def org
+          @org ||= if URI.parse(chef_server_url).path =~ /^\/+organizations\/+([^\/]+)$/
+            $1
+          else
+            nil
+          end
+        end
+
         def children
           @children ||= begin
             result = [
               CookbooksDir.new(self),
               DataBagsDir.new(self),
-              RestListDir.new("environments", self),
-              RestListDir.new("roles", self)
+              EnvironmentsDir.new(self),
+              RestListDir.new("roles", self, nil, Chef::ChefFS::DataHandler::RoleDataHandler.new)
             ]
-            if repo_mode == 'everything'
+            if repo_mode == 'hosted_everything'
+              result += [
+                AclsDir.new(self),
+                RestListDir.new("clients", self, nil, Chef::ChefFS::DataHandler::ClientDataHandler.new),
+                RestListDir.new("containers", self, nil, Chef::ChefFS::DataHandler::ContainerDataHandler.new),
+                RestListDir.new("groups", self, nil, Chef::ChefFS::DataHandler::GroupDataHandler.new),
+                NodesDir.new(self)
+              ]
+            elsif repo_mode != 'static'
               result += [
-                RestListDir.new("clients", self),
+                RestListDir.new("clients", self, nil, Chef::ChefFS::DataHandler::ClientDataHandler.new),
                 NodesDir.new(self),
-                RestListDir.new("users", self)
+                RestListDir.new("users", self, nil, Chef::ChefFS::DataHandler::UserDataHandler.new)
               ]
             end
             result.sort_by { |child| child.name }
           end
         end
-
-        # Yeah, sorry, I'm not putting delete on this thing.
       end
     end
   end