knife-essentials 0.1.1 → 0.2

data/lib/chef/knife/list.rb

@@ -52,7 +52,7 @@ class Chef
       def add_dir_result(result)
         begin
           children = result.children.sort_by { |child| child.name }
-        rescue ChefFS::FileSystem::NotFoundException
+        rescue ChefFS::FileSystem::NotFoundError
           STDERR.puts "#{format_path(result.path)}: No such file or directory"
           return []
         end

data/lib/chef/knife/show.rb

@@ -17,7 +17,7 @@ class Chef
                 value = result.read
                 puts "#{format_path(result.path)}:"
                 output(format_for_display(result.read))
-              rescue ChefFS::FileSystem::NotFoundException
+              rescue ChefFS::FileSystem::NotFoundError
                 STDERR.puts "#{format_path(result.path)}: No such file or directory" if pattern.exact_path
               end
             end

data/lib/chef_fs/command_line.rb

@@ -27,7 +27,7 @@ module ChefFS
           result << "Common subdirectories: #{old_file.path}\n"
         elsif new_file.exists?
           result << "File #{new_file.path_for_printing} is a directory while file #{new_file.path_for_printing} is a regular file\n"
-        else
+        elsif new_file.parent.can_have_child?(old_file.name, old_file.dir?)
           result << "Only in #{old_file.parent.path_for_printing}: #{old_file.name}\n"
         end
 
@@ -36,7 +36,7 @@ module ChefFS
       elsif new_file.dir?
         if old_file.exists?
           result << "File #{old_file.path_for_printing} is a regular file while file #{old_file.path_for_printing} is a directory\n"
-        else
+        elsif old_file.parent.can_have_child?(new_file.name, new_file.dir?)
           result << "Only in #{new_file.parent.path_for_printing}: #{new_file.name}\n"
         end
 
@@ -44,6 +44,15 @@ module ChefFS
         # Neither is a directory, so they are diffable with file diff
         different, old_value, new_value = ChefFS::Diff::diff_files(old_file, new_file)
         if different
+          # If one of the files doesn't exist, we only want to print the diff if the
+          # other file *could be synced*.
+          if !old_value && !old_file.parent.can_have_child?(new_file.name, new_file.dir?)
+            return result
+          end
+          if !new_value && !new_file.parent.can_have_child?(old_file.name, old_file.dir?)
+            return result
+          end
+
           old_path = old_file.path_for_printing
           new_path = new_file.path_for_printing
           result << "diff --knife #{old_path} #{new_path}\n"

data/lib/chef_fs/diff.rb

@@ -149,7 +149,7 @@ module ChefFS
     def self.read_file_value(file)
       begin
         return file.read
-      rescue ChefFS::FileSystem::NotFoundException
+      rescue ChefFS::FileSystem::NotFoundError
         return nil
       end
     end

data/lib/chef_fs/file_system/base_fs_dir.rb

@@ -17,6 +17,10 @@ module ChefFS
         children.select { |child| child.name == name }.first || NonexistentFSObject.new(name, self)
       end
 
+      def can_have_child?(name, is_dir)
+        true
+      end
+
       # Abstract: children
     end
   end

data/lib/chef_fs/file_system/base_fs_object.rb

@@ -44,6 +44,17 @@ module ChefFS
         :text
       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
+
       # Important directory attributes: name, parent, path, root
       # Overridable attributes: dir?, child(name), path_for_printing
       # Abstract: read, write, delete, children

data/lib/chef_fs/file_system/chef_repository_file_system_entry.rb

@@ -0,0 +1,46 @@
+require 'chef_fs/file_system/file_system_entry'
+require 'chef/cookbook/chefignore'
+
+module ChefFS
+  module FileSystem
+    # ChefRepositoryFileSystemEntry works just like FileSystemEntry,
+    # except it pretends files in /cookbooks/chefignore don't exist
+    class ChefRepositoryFileSystemEntry < FileSystemEntry
+      def initialize(name, parent, file_path = 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)
+        end
+      end
+
+      def children
+        @children ||= Dir.entries(file_path).select { |entry| entry != '.' && entry != '..' && !ignored?(entry) }
+                                            .map { |entry| ChefRepositoryFileSystemEntry.new(entry, self) }
+      end
+
+      attr_reader :chefignore
+
+      private
+
+      def ignored?(child_name)
+        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
+      end
+
+    end
+  end
+end

data/lib/chef_fs/file_system/chef_repository_file_system_root_dir.rb

@@ -0,0 +1,11 @@
+require 'chef_fs/file_system/chef_repository_file_system_entry'
+
+module ChefFS
+  module FileSystem
+    class ChefRepositoryFileSystemRootDir < ChefRepositoryFileSystemEntry
+      def initialize(file_path)
+        super("", nil, file_path)
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/chef_server_root_dir.rb

@@ -29,7 +29,11 @@ module ChefFS
       end
 
       def path_for_printing
-        @root_name
+        "#{@root_name}/"
+      end
+
+      def can_have_child?(name, is_dir)
+        is_dir && children.any? { |child| child.name == name }
       end
 
       def children

data/lib/chef_fs/file_system/cookbook_dir.rb

@@ -1,6 +1,7 @@
 require 'chef_fs/file_system/rest_list_dir'
 require 'chef_fs/file_system/cookbook_subdir'
 require 'chef_fs/file_system/cookbook_file'
+require 'chef_fs/file_system/not_found_error'
 require 'chef/cookbook_version'
 
 module ChefFS
@@ -13,6 +14,18 @@ module ChefFS
 
       attr_reader :versions
 
+      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
@@ -22,23 +35,42 @@ module ChefFS
       end
 
       def child(name)
-        children.select { |child| child.name == name }.first || NonexistentFSObject.new(name, self)
+        # 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 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
+        if is_dir
+          return name != 'root_files' && COOKBOOK_SEGMENT_INFO.keys.any? { |segment| segment.to_s == name }
+        end
+        true
       end
 
       def children
         if @children.nil?
           @children = []
-          Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+          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('/')
+              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)
+                  container = CookbookSubdir.new(part, old_container, segment_info[:ruby_only], segment_info[:recursive])
                   old_container.add_child(container)
                 end
               end
@@ -56,7 +88,7 @@ module ChefFS
 
       def read
         # This will only be called if dir? is false, which means exists? is false.
-        raise ChefFS::FileSystem::NotFoundException, path_for_printing
+        raise ChefFS::FileSystem::NotFoundError, path_for_printing
       end
 
       def exists?
@@ -74,11 +106,35 @@ module ChefFS
       private
 
       def manifest
+        # The negative (not found) response is cached
+        if @could_not_get_manifest
+          raise ChefFS::FileSystem::NotFoundError.new(@could_not_get_manifest), "#{path_for_printing} not found"
+        end
+
         begin
-          @manifest ||= rest.get_rest(api_path).manifest
+          # We want to fail fast, for now, because of the 500 issue :/
+          # This will make things worse for parallelism, a little.
+          old_retry_count = Chef::Config[:http_retry_count]
+          begin
+            Chef::Config[:http_retry_count] = 0
+            @manifest ||= rest.get_rest(api_path).manifest
+          ensure
+            Chef::Config[:http_retry_count] = old_retry_count
+          end
         rescue Net::HTTPServerException
           if $!.response.code == "404"
-            raise ChefFS::FileSystem::NotFoundException, $!
+            @could_not_get_manifest = $!
+            raise ChefFS::FileSystem::NotFoundError.new(@could_not_get_manifest), "#{path_for_printing} not found"
+          else
+            raise
+          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
+          if $!.response.code == "500"
+            @could_not_get_manifest = $!
+            raise ChefFS::FileSystem::NotFoundError.new(@could_not_get_manifest), "#{path_for_printing} not found"
           else
             raise
           end

data/lib/chef_fs/file_system/cookbook_file.rb

@@ -18,9 +18,9 @@ module ChefFS
         old_sign_on_redirect = rest.sign_on_redirect
         rest.sign_on_redirect = false
         begin
-          rest.get_rest(file['url'])
+          rest.get_rest(file[:url])
         ensure
-          rest.sign_on_redirect = true
+          rest.sign_on_redirect = old_sign_on_redirect
         end
       end
 

data/lib/chef_fs/file_system/cookbook_subdir.rb

@@ -5,9 +5,11 @@ require 'chef_fs/file_system/base_fs_dir'
 module ChefFS
   module FileSystem
     class CookbookSubdir < BaseFSDir
-      def initialize(name, parent)
+      def initialize(name, parent, ruby_only, recursive)
         super(name, parent)
         @children = []
+        @ruby_only = ruby_only
+        @recursive = recursive
       end
 
       attr_reader :versions
@@ -17,6 +19,15 @@ module ChefFS
         @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

data/lib/chef_fs/file_system/cookbooks_dir.rb

@@ -16,6 +16,10 @@ module ChefFS
       def children
         @children ||= rest.get_rest(api_path).map { |key, value| CookbookDir.new(key, self, value) }
       end
+
+      def can_have_child?(name, is_dir)
+        is_dir
+      end
     end
   end
 end

data/lib/chef_fs/file_system/data_bag_dir.rb

@@ -1,5 +1,6 @@
 require 'chef_fs/file_system/base_fs_dir'
 require 'chef_fs/file_system/rest_list_entry'
+require 'chef_fs/file_system/not_found_error'
 
 # TODO: take environment into account
 
@@ -17,7 +18,7 @@ module ChefFS
 
       def read
         # This will only be called if dir? is false, which means exists? is false.
-        raise ChefFS::FileSystem::NotFoundException, path_for_printing
+        raise ChefFS::FileSystem::NotFoundError, "#{path_for_printing} not found"
       end
 
       def exists?

data/lib/chef_fs/file_system/data_bags_dir.rb

@@ -18,6 +18,10 @@ module ChefFS
       def children
         @children ||= rest.get_rest(api_path).keys.map { |entry| DataBagDir.new(entry, self, true) }
       end
+
+      def can_have_child?(name, is_dir)
+        is_dir
+      end
     end
   end
 end

data/lib/chef_fs/file_system/file_system_entry.rb

@@ -1,5 +1,6 @@
 require 'chef_fs/file_system/base_fs_dir'
 require 'chef_fs/file_system/rest_list_dir'
+require 'chef_fs/file_system/not_found_error'
 require 'chef_fs/path_utils'
 
 module ChefFS
@@ -17,7 +18,7 @@ module ChefFS
       end
 
       def children
-        @children ||= Dir.entries(file_path).select { |entry| entry[0] != "." }.map { |entry| FileSystemEntry.new(entry, self) }
+        @children ||= Dir.entries(file_path).select { |entry| entry != '.' && entry != '..' }.map { |entry| FileSystemEntry.new(entry, self) }
       end
 
       def dir?
@@ -27,8 +28,8 @@ module ChefFS
       def read
         begin
           IO.read(file_path)
-        rescue IONotFoundException # TODO real exception
-          raise NotFoundException, $!
+        rescue IONotFoundError # TODO real exception
+          raise ChefFS::FileSystem::NotFoundError.new($!), "#{path_for_printing} not found"
         end
       end
     end

data/lib/chef_fs/file_system/nonexistent_fs_object.rb

@@ -1,4 +1,5 @@
 require 'chef_fs/file_system/base_fs_object'
+require 'chef_fs/file_system/not_found_error'
 
 module ChefFS
   module FileSystem
@@ -11,12 +12,8 @@ module ChefFS
         false
       end
 
-      def child(name)
-        NonexistentFSObject.new(name, self)
-      end
-
       def read
-        raise ChefFS::FileSystem::NotFoundException, "Nonexistent object"
+        raise ChefFS::FileSystem::NotFoundError, "Nonexistent #{path_for_printing}"
       end
     end
   end

data/lib/chef_fs/file_system/not_found_error.rb

@@ -0,0 +1,11 @@
+module ChefFS
+  module FileSystem
+    class NotFoundError < StandardError
+      def initialize(cause = nil)
+        @cause = cause
+      end
+
+      attr_reader :cause
+    end
+  end
+end

data/lib/chef_fs/file_system/rest_list_dir.rb

@@ -1,5 +1,6 @@
 require 'chef_fs/file_system/base_fs_dir'
 require 'chef_fs/file_system/rest_list_entry'
+require 'chef_fs/file_system/not_found_error'
 
 # TODO: take environment into account
 
@@ -18,12 +19,16 @@ module ChefFS
         result || RestListEntry.new(name, self)
       end
 
+      def can_have_child?(name, is_dir)
+        name =~ /\.json$/ && !is_dir
+      end
+
       def children
         begin
           @children ||= rest.get_rest(api_path).keys.map { |key| RestListEntry.new("#{key}.json", self, true) }
         rescue Net::HTTPServerException
           if $!.response.code == "404"
-            raise ChefFS::FileSystem::NotFoundException, $!
+            raise ChefFS::FileSystem::NotFoundError.new($!), "#{path_for_printing} not found"
           else
             raise
           end