knife-essentials 0.8.3 → 0.8.4

data/lib/chef_fs/file_system/base_fs_object.rb

@@ -17,6 +17,7 @@
 #
 
 require 'chef_fs/path_utils'
+require 'chef_fs/file_system/operation_not_allowed_error'
 
 module ChefFS
   module FileSystem
@@ -38,42 +39,6 @@ module ChefFS
       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
-            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,
@@ -111,14 +76,103 @@ module ChefFS
         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, "Nonexistent #{path_for_printing}" if !exists?
+        []
+      end
+
+      # Expand this entry into a chef object (Chef::Role, ::Node, etc.)
       def chef_object
-        raise ChefFS::FileSystem::NotFoundError, "Nonexistent #{path_for_printing}" if !exists?
+        raise NotFoundError, "Nonexistent #{path_for_printing}" 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, "Nonexistent #{path_for_printing}" if !exists?
+        raise OperationNotAllowedError.new(:create_child), "#{path_for_printing} cannot have a child created under it."
+      end
+
+      # Delete this item, possibly recursively.  Entries MUST NOT delete a
+      # directory unless recurse is true.
+      def delete(recurse)
+        raise NotFoundError, "Nonexistent #{path_for_printing}" if !exists?
+        raise OperationNotAllowedError.new(:delete), "#{path_for_printing} cannot be deleted."
+      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
+            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, "Nonexistent #{path_for_printing}" if !exists?
+        raise OperationNotAllowedError.new(:read), "#{path_for_printing} cannot be read."
+      end
+
+      # Write the contents of this file entry.
+      def write(file_contents)
+        raise NotFoundError, "Nonexistent #{path_for_printing}" if !exists?
+        raise OperationNotAllowedError.new(:write), "#{path_for_printing} cannot be updated."
+      end
+
       # Important directory attributes: name, parent, path, root
       # Overridable attributes: dir?, child(name), path_for_printing
       # Abstract: read, write, delete, children, can_have_child?, create_child, compare_to
     end
   end
 end
+
+require 'chef_fs/file_system/nonexistent_fs_object'

data/lib/chef_fs/file_system/chef_repository_file_system_cookbooks_dir.rb

@@ -24,7 +24,11 @@ module ChefFS
     class ChefRepositoryFileSystemCookbooksDir < ChefRepositoryFileSystemEntry
       def initialize(name, parent, file_path)
         super(name, parent, file_path)
-        @chefignore = Chef::Cookbook::Chefignore.new(self.file_path)
+        begin
+          @chefignore = Chef::Cookbook::Chefignore.new(self.file_path)
+        rescue Errno::EISDIR
+          # Work around a bug in Chefignore when chefignore is a directory
+        end
       end
 
       attr_reader :chefignore
@@ -32,6 +36,15 @@ module ChefFS
       def ignore_empty_directories?
         true
       end
+
+      def ignored?(entry)
+        return true if !entry.dir?
+        result = super(entry)
+        if result
+          Chef::Log.warn("Cookbook '#{entry.name}' is empty or entirely chefignored at #{entry.path_for_printing}")
+        end
+        result
+      end
     end
   end
 end

data/lib/chef_fs/file_system/chef_server_root_dir.rb

@@ -21,6 +21,7 @@ require 'chef_fs/file_system/rest_list_dir'
 require 'chef_fs/file_system/cookbooks_dir'
 require 'chef_fs/file_system/data_bags_dir'
 require 'chef_fs/file_system/nodes_dir'
+require 'chef_fs/file_system/environments_dir'
 
 module ChefFS
   module FileSystem
@@ -62,7 +63,7 @@ module ChefFS
           result = [
             CookbooksDir.new(self),
             DataBagsDir.new(self),
-            RestListDir.new("environments", self),
+            EnvironmentsDir.new(self),
             RestListDir.new("roles", self)
           ]
           if repo_mode == 'everything'

data/lib/chef_fs/file_system/cookbook_file.rb

@@ -37,7 +37,13 @@ module ChefFS
         old_sign_on_redirect = rest.sign_on_redirect
         rest.sign_on_redirect = false
         begin
-          rest.get_rest(file[:url])
+          begin
+            tmpfile = rest.get_rest(file[:url], true)
+            tmpfile.open
+            tmpfile.read
+          ensure
+            tmpfile.close!
+          end
         ensure
           rest.sign_on_redirect = old_sign_on_redirect
         end

data/lib/chef_fs/file_system/cookbooks_dir.rb

@@ -44,12 +44,19 @@ module ChefFS
         # 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)
-          # Chef 11 changes this API
-          if uploader.respond_to?(:upload_cookbook)
-            uploader.upload_cookbook
-          else
-            uploader.upload_cookbooks
+          uploader = Chef::CookbookUploader.new(other_cookbook_version, other.parent.file_path, :rest => rest)
+          # Work around the fact that CookbookUploader doesn't understand chef_repo_path (yet)
+          old_cookbook_path = Chef::Config.cookbook_path
+          Chef::Config.cookbook_path = other.parent.file_path if !Chef::Config.cookbook_path
+          begin
+            # Chef 11 changes this API
+            if uploader.respond_to?(:upload_cookbook)
+              uploader.upload_cookbook
+            else
+              uploader.upload_cookbooks
+            end
+          ensure
+            Chef::Config.cookbook_path = old_cookbook_path
           end
         rescue Net::HTTPServerException => e
           case e.response.code

data/lib/chef_fs/file_system/environments_dir.rb

@@ -0,0 +1,59 @@
+#
+# 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_fs/file_system/base_fs_dir'
+require 'chef_fs/file_system/rest_list_entry'
+require 'chef_fs/file_system/not_found_error'
+require 'chef_fs/file_system/operation_skipped_error'
+
+module ChefFS
+  module FileSystem
+    class EnvironmentsDir < RestListDir
+      def initialize(parent)
+        super("environments", parent)
+      end
+
+      def _make_child_entry(name, exists = nil)
+        if name == '_default.json'
+          DefaultEnvironmentEntry.new(name, self, exists)
+        else
+          super
+        end
+      end
+
+      class DefaultEnvironmentEntry < RestListEntry
+        def initialize(name, parent, exists = nil)
+          super(name, parent)
+          @exists = exists
+        end
+
+        def delete(recurse)
+          Chef::Log.warn("The default environment (#{name}) cannot be deleted.  Skipping.")
+          raise NotFoundError, "Nonexistent #{path_for_printing}" if !exists?
+          raise OperationSkippedError.new(:delete), "#{path_for_printing} cannot be deleted."
+        end
+
+        def write(file_contents)
+          Chef::Log.warn("The default environment (#{name}) cannot be deleted.  Skipping.")
+          raise NotFoundError, "Nonexistent #{path_for_printing}" if !exists?
+          raise OperationSkippedError.new(:write), "#{path_for_printing} cannot be updated."
+        end
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/multiplexed_dir.rb

@@ -23,7 +23,7 @@ module ChefFS
           multiplexed_dirs.each do |dir|
             dir.children.each do |child|
               if seen[child.name]
-                Chef::Log.warn("Child with name '#{child.name}' found in multiple directories: #{child.path_for_printing} and #{seen[child.name].path_for_printing}")
+                Chef::Log.warn("Child with name '#{child.name}' found in multiple directories: #{seen[child.name].path_for_printing} and #{child.path_for_printing}")
               else
                 result << child
                 seen[child.name] = child

data/lib/chef_fs/file_system/nodes_dir.rb

@@ -28,6 +28,7 @@ module ChefFS
       end
 
       # Override children to respond to environment
+      # TODO let's not do this mmkay
       def children
         @children ||= begin
           env_api_path = environment ? "environments/#{environment}/#{api_path}" : api_path

data/lib/chef_fs/file_system/operation_not_allowed_error.rb

@@ -0,0 +1,29 @@
+#
+# 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_fs/file_system/file_system_error'
+
+module ChefFS
+  module FileSystem
+    class OperationNotAllowedError < FileSystemError
+      def initialize(operation, cause = nil)
+        super(cause)
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/operation_skipped_error.rb

@@ -0,0 +1,29 @@
+#
+# 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_fs/file_system/operation_not_allowed_error'
+
+module ChefFS
+  module FileSystem
+    class OperationSkippedError < OperationNotAllowedError
+      def initialize(operation, cause = nil)
+        super(operation, cause)
+      end
+    end
+  end
+end

data/lib/chef_fs/knife.rb

@@ -35,32 +35,38 @@ module ChefFS
       @chef_fs ||= ChefFS::FileSystem::ChefServerRootDir.new("remote", Chef::Config, config[:repo_mode])
     end
 
-    def chef_repo_path
-      @chef_repo_path ||= begin
-        if Chef::Config.chef_repo_path
-          File.expand_path(Chef::Config.chef_repo_path)
-        elsif Chef::Config.cookbook_path
-          File.expand_path('..', Array(Chef::Config.cookbook_path).flatten.first)
+    def chef_repo_paths
+      @chef_repo_paths ||= begin
+        result = config_paths(:chef_repo_path)
+        if result
+          result
         else
-          nil
+          if Chef::Config[:cookbook_path]
+            Array(Chef::Config[:cookbook_path]).flatten.map { |path| File.expand_path('..', path) }
+          else
+            nil
+          end
         end
       end
     end
 
     # Smooth out some inappropriate (for now) variable defaults in Chef.
-    def config_var(name)
-      case name
+    def config_paths(name)
+      result = case name
       when :data_bag_path
         Chef::Config[name] == Chef::Config.platform_specific_path('/var/chef/data_bags') ? nil : Chef::Config[name]
       when :node_path
         Chef::Config[name] == '/var/chef/node' ? nil : Chef::Config[name]
       when :role_path
         Chef::Config[name] == Chef::Config.platform_specific_path('/var/chef/roles') ? nil : Chef::Config[name]
-      when :chef_repo_path
-        chef_repo_path
       else
         Chef::Config[name]
       end
+      if result
+        Array(result).flatten
+      else
+        nil
+      end
     end
 
     def object_paths
@@ -73,17 +79,15 @@ module ChefFS
         end
         object_names.each do |object_name|
           variable_name = "#{object_name[0..-2]}_path" # cookbooks -> cookbook_path
-          paths = config_var(variable_name.to_sym)
+          paths = config_paths(variable_name.to_sym)
           if !paths
-            if !chef_repo_path
-              # TODO if chef_repo is not specified and repo_mode does not require
-              # clients/users/nodes, don't require them to be specified.
+            if !chef_repo_paths
               Chef::Log.error("Must specify either chef_repo_path or #{variable_name} in Chef config file")
               exit(1)
             end
-            paths = File.join(chef_repo_path, object_name)
+            paths = chef_repo_paths.map { |path| File.join(path, object_name) }
           end
-          paths = Array(paths).flatten.map { |path| File.expand_path(path) }
+          paths = paths.flatten.map { |path| File.expand_path(path) }
           result[object_name] = paths
         end
         result
@@ -118,7 +122,9 @@ module ChefFS
       object_paths.each_pair do |name, paths|
         paths.each do |path|
           realest_path = ChefFS::PathUtils.realest_path(path)
-          if absolute_path[0,realest_path.length] == realest_path
+          if absolute_path[0,realest_path.length] == realest_path &&
+            (absolute_path.length == realest_path.length ||
+              absolute_path[realest_path.length] =~ /#{PathUtils.regexp_path_separator}/)
             relative_path = ChefFS::PathUtils::relative_to(absolute_path, realest_path)
             return relative_path == '.' ? "/#{name}" : "/#{name}/#{relative_path}"
           end
@@ -126,9 +132,11 @@ module ChefFS
       end
 
       # Check chef_repo_path
-      realest_chef_repo_path = ChefFS::PathUtils.realest_path(chef_repo_path)
-      if absolute_path == realest_chef_repo_path
-        return '/'
+      chef_repo_paths.each do |chef_repo_path|
+        realest_chef_repo_path = ChefFS::PathUtils.realest_path(chef_repo_path)
+        if absolute_path == realest_chef_repo_path
+          return '/'
+        end
       end
 
       nil