knife-essentials 0.8.3 → 0.8.4

data/lib/chef/knife/diff_essentials.rb

@@ -37,8 +37,8 @@ class Chef
 
         # Get the matches (recursively)
         patterns.each do |pattern|
-          ChefFS::CommandLine.diff(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode) do |diff|
-            output diff
+          ChefFS::CommandLine.diff_print(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode, proc { |entry| format_path(entry.path) } ) do |diff|
+            stdout.print diff
           end
         end
       end

data/lib/chef/knife/download_essentials.rb

@@ -42,8 +42,12 @@ class Chef
           exit 1
         end
 
+        error = false
         pattern_args.each do |pattern|
-          ChefFS::FileSystem.copy_to(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, config, ui)
+          error ||= ChefFS::FileSystem.copy_to(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, config, ui, proc { |entry| format_path(entry.path) })
+        end
+        if error
+          exit 1
         end
       end
     end

data/lib/chef/knife/list_essentials.rb

@@ -6,7 +6,7 @@ class Chef
     remove_const(:List) if const_defined?(:List) && List.name == 'Chef::Knife::List' # override Chef's version
     class List < ::ChefFS::Knife
       ChefFS = ::ChefFS
-      banner "knife list [-dR] [PATTERN1 ... PATTERNn]"
+      banner "knife list [-dfR1p] [PATTERN1 ... PATTERNn]"
 
       common_options
 
@@ -23,6 +23,7 @@ class Chef
         :boolean => true,
         :description => "List local directory instead of remote"
       option :flat,
+        :short => '-f',
         :long => '--flat',
         :boolean => true,
         :description => "Show a list of filenames rather than the prettified ls-like output normally produced"

data/lib/chef/knife/upload_essentials.rb

@@ -42,8 +42,12 @@ class Chef
           exit 1
         end
 
+        error = false
         pattern_args.each do |pattern|
-          ChefFS::FileSystem.copy_to(pattern, local_fs, chef_fs, config[:recurse] ? nil : 1, config, ui)
+          error ||= ChefFS::FileSystem.copy_to(pattern, local_fs, chef_fs, config[:recurse] ? nil : 1, config, ui, proc { |entry| format_path(entry.path) })
+        end
+        if error
+          exit 1
         end
       end
     end

data/lib/chef_fs/command_line.rb

@@ -20,10 +20,85 @@ require 'chef_fs/file_system'
 
 module ChefFS
   module CommandLine
-    def self.diff(pattern, a_root, b_root, recurse_depth, output_mode)
+
+    def self.diff_print(pattern, a_root, b_root, recurse_depth, output_mode, format_path = nil)
+      if format_path.nil?
+        format_path = proc { |entry| entry.path_for_printing }
+      end
+
+      get_content = (output_mode != :name_only && output_mode != :name_status)
+      diff(pattern, a_root, b_root, recurse_depth, get_content) do |type, old_entry, new_entry, old_value, new_value|
+        old_path = format_path.call(old_entry)
+        new_path = format_path.call(new_entry)
+
+        if get_content && old_value && new_value
+          result = ''
+          result << "diff --knife #{old_path} #{new_path}\n"
+          if old_value == :none
+            result << "new file\n"
+            old_path = "/dev/null"
+            old_value = ''
+          end
+          if new_value == :none
+            result << "deleted file\n"
+            new_path = "/dev/null"
+            new_value = ''
+          end
+          result << diff_text(old_path, new_path, old_value, new_value)
+          yield result
+        else
+          case type
+          when :common_subdirectories
+            if output_mode != :name_only && output_mode != :name_status
+              yield "Common subdirectories: #{new_path}\n"
+            end
+          when :directory_to_file
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "T\t#{new_path}\n"
+            else
+              yield "File #{old_path} is a directory while file #{new_path} is a regular file\n"
+            end
+          when :file_to_directory
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "T\t#{new_path}\n"
+            else
+              yield "File #{old_path} is a regular file while file #{new_path} is a directory\n"
+            end
+          when :deleted
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "D\t#{new_path}\n"
+            else
+              yield "Only in #{format_path.call(old_entry.parent)}: #{old_entry.name}\n"
+            end
+          when :added
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "A\t#{new_path}\n"
+            else
+              yield "Only in #{format_path.call(new_entry.parent)}: #{new_entry.name}\n"
+            end
+          when :modified
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "M\t#{new_path}\n"
+            end
+          end
+        end
+      end
+    end
+
+    def self.diff(pattern, a_root, b_root, recurse_depth, get_content)
       found_result = false
       ChefFS::FileSystem.list_pairs(pattern, a_root, b_root) do |a, b|
-        existed = diff_entries(a, b, recurse_depth, output_mode) do |diff|
+        existed = diff_entries(a, b, recurse_depth, get_content) do |diff|
           yield diff
         end
         found_result = true if existed
@@ -34,18 +109,16 @@ module ChefFS
     end
 
     # Diff two known entries (could be files or dirs)
-    def self.diff_entries(old_entry, new_entry, recurse_depth, output_mode)
+    def self.diff_entries(old_entry, new_entry, recurse_depth, get_content)
       # If both are directories
       if old_entry.dir?
         if new_entry.dir?
           if recurse_depth == 0
-            if output_mode != :name_only && output_mode != :name_status
-              yield "Common subdirectories: #{old_entry.path}\n"
-            end
+            yield [ :common_subdirectories, old_entry, new_entry ]
           else
             ChefFS::FileSystem.child_pairs(old_entry, new_entry).each do |old_child,new_child|
               diff_entries(old_child, new_child,
-                           recurse_depth ? recurse_depth - 1 : nil, output_mode) do |diff|
+                           recurse_depth ? recurse_depth - 1 : nil, get_content) do |diff|
                 yield diff
               end
             end
@@ -53,45 +126,21 @@ module ChefFS
 
       # If old is a directory and new is a file
         elsif new_entry.exists?
-          if output_mode == :name_only
-            yield "#{new_entry.path_for_printing}\n"
-          elsif output_mode == :name_status
-            yield "T\t#{new_entry.path_for_printing}\n"
-          else
-            yield "File #{new_entry.path_for_printing} is a directory while file #{new_entry.path_for_printing} is a regular file\n"
-          end
+          yield [ :directory_to_file, old_entry, new_entry ]
 
       # If old is a directory and new does not exist
         elsif new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
-          if output_mode == :name_only
-            yield "#{new_entry.path_for_printing}\n"
-          elsif output_mode == :name_status
-            yield "D\t#{new_entry.path_for_printing}\n"
-          else
-            yield "Only in #{old_entry.parent.path_for_printing}: #{old_entry.name}\n"
-          end
+          yield [ :deleted, old_entry, new_entry ]
         end
 
       # If new is a directory and old is a file
       elsif new_entry.dir?
         if old_entry.exists?
-          if output_mode == :name_only
-            yield "#{new_entry.path_for_printing}\n"
-          elsif output_mode == :name_status
-            yield "T\t#{new_entry.path_for_printing}\n"
-          else
-            yield "File #{old_entry.path_for_printing} is a regular file while file #{old_entry.path_for_printing} is a directory\n"
-          end
+          yield [ :file_to_directory, old_entry, new_entry ]
 
       # If new is a directory and old does not exist
         elsif old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
-          if output_mode == :name_only
-            yield "#{new_entry.path_for_printing}\n"
-          elsif output_mode == :name_status
-            yield "A\t#{new_entry.path_for_printing}\n"
-          else
-            yield "Only in #{new_entry.parent.path_for_printing}: #{new_entry.name}\n"
-          end
+          yield [ :added, old_entry, new_entry ]
         end
 
       # Neither is a directory, so they are diffable with file diff
@@ -107,6 +156,7 @@ module ChefFS
           else
             old_exists = true
           end
+
           if new_value == :none
             new_exists = false
           elsif new_value.nil?
@@ -124,18 +174,8 @@ module ChefFS
             return true
           end
 
-          if output_mode == :name_only
-            yield "#{new_entry.path_for_printing}\n"
-          elsif output_mode == :name_status
-            if old_value == :none || (old_value == nil && !old_entry.exists?)
-              yield "A\t#{new_entry.path_for_printing}\n"
-            elsif new_value == :none
-              yield "D\t#{new_entry.path_for_printing}\n"
-            else
-              yield "M\t#{new_entry.path_for_printing}\n"
-            end
-          else
-            # If we haven't read the values yet, get them now.
+          if get_content
+            # If we haven't read the values yet, get them now so that they can be diffed
             begin
               old_value = old_entry.read if old_value.nil?
             rescue ChefFS::FileSystem::NotFoundError
@@ -146,23 +186,14 @@ module ChefFS
             rescue ChefFS::FileSystem::NotFoundError
               new_value = :none
             end
+          end
 
-            old_path = old_entry.path_for_printing
-            new_path = new_entry.path_for_printing
-            result = ''
-            result << "diff --knife #{old_path} #{new_path}\n"
-            if old_value == :none
-              result << "new file\n"
-              old_path = "/dev/null"
-              old_value = ''
-            end
-            if new_value == :none
-              result << "deleted file\n"
-              new_path = "/dev/null"
-              new_value = ''
-            end
-            result << diff_text(old_path, new_path, old_value, new_value)
-            yield result
+          if old_value == :none || (old_value == nil && !old_entry.exists?)
+            yield [ :added, old_entry, new_entry, old_value, new_value ]
+          elsif new_value == :none
+            yield [ :deleted, old_entry, new_entry, old_value, new_value ]
+          else
+            yield [ :modified, old_entry, new_entry, old_value, new_value ]
           end
         end
       end

data/lib/chef_fs/file_system.rb

@@ -17,6 +17,8 @@
 #
 
 require 'chef_fs/path_utils'
+require 'chef_fs/file_system/operation_skipped_error'
+require 'chef_fs/file_system/operation_not_allowed_error'
 
 module ChefFS
   module FileSystem
@@ -112,16 +114,20 @@ module ChefFS
     #       puts message
     #     end
     #
-    def self.copy_to(pattern, src_root, dest_root, recurse_depth, options, ui)
+    def self.copy_to(pattern, src_root, dest_root, recurse_depth, options, ui, format_path)
       found_result = false
+      error = false
       list_pairs(pattern, src_root, dest_root) do |src, dest|
         found_result = true
-        new_dest_parent = get_or_create_parent(dest, options, ui)
-        copy_entries(src, dest, new_dest_parent, recurse_depth, options, ui)
+        new_dest_parent = get_or_create_parent(dest, options, ui, format_path)
+        child_error = copy_entries(src, dest, new_dest_parent, recurse_depth, options, ui, format_path)
+        error ||= child_error
       end
       if !found_result && pattern.exact_path
         ui.error "#{pattern}: No such file or directory on remote or local"
+        error = true
       end
+      error
     end
 
     # Yield entries for children that are in either +a_root+ or +b_root+, with
@@ -215,7 +221,7 @@ module ChefFS
     private
 
     # Copy two entries (could be files or dirs)
-    def self.copy_entries(src_entry, dest_entry, new_dest_parent, recurse_depth, options, ui)
+    def self.copy_entries(src_entry, dest_entry, new_dest_parent, recurse_depth, options, ui, format_path)
       # A NOTE about this algorithm:
       # There are cases where this algorithm does too many network requests.
       # knife upload with a specific filename will first check if the file
@@ -227,126 +233,140 @@ module ChefFS
       # exist.
       # Will need to decide how that works with checksums, though.
 
-      if !src_entry.exists?
-        if options[:purge]
-          # If we would not have uploaded it, we will not purge it.
-          if src_entry.parent.can_have_child?(dest_entry.name, dest_entry.dir?)
-            if options[:dry_run]
-              ui.output "Would delete #{dest_entry.path_for_printing}"
+      error = false
+      begin
+        dest_path = format_path.call(dest_entry)
+        src_path = format_path.call(src_entry)
+        if !src_entry.exists?
+          if options[:purge]
+            # If we would not have uploaded it, we will not purge it.
+            if src_entry.parent.can_have_child?(dest_entry.name, dest_entry.dir?)
+              if options[:dry_run]
+                ui.output "Would delete #{dest_path}"
+              else
+                dest_entry.delete(true)
+                ui.output "Deleted extra entry #{dest_path} (purge is on)"
+              end
             else
-              dest_entry.delete(true)
-              ui.output "Deleted extra entry #{dest_entry.path_for_printing} (purge is on)"
+              Chef::Log.info("Not deleting extra entry #{dest_path} (purge is off)")
             end
-          else
-            Chef::Log.info("Not deleting extra entry #{dest_entry.path_for_printing} (purge is off)")
           end
-        end
 
-      elsif !dest_entry.exists?
-        if new_dest_parent.can_have_child?(src_entry.name, src_entry.dir?)
-          # If the entry can do a copy directly from filesystem, do that.
-          if new_dest_parent.respond_to?(:create_child_from)
-            if options[:dry_run]
-              ui.output "Would create #{dest_entry.path_for_printing}"
-            else
-              new_dest_parent.create_child_from(src_entry)
-              ui.output "Created #{dest_entry.path_for_printing}"
+        elsif !dest_entry.exists?
+          if new_dest_parent.can_have_child?(src_entry.name, src_entry.dir?)
+            # If the entry can do a copy directly from filesystem, do that.
+            if new_dest_parent.respond_to?(:create_child_from)
+              if options[:dry_run]
+                ui.output "Would create #{dest_path}"
+              else
+                new_dest_parent.create_child_from(src_entry)
+                ui.output "Created #{dest_path}"
+              end
+              return
             end
-            return
-          end
 
-          if src_entry.dir?
-            if options[:dry_run]
-              ui.output "Would create #{dest_entry.path_for_printing}"
-              new_dest_dir = new_dest_parent.child(src_entry.name)
-            else
-              new_dest_dir = new_dest_parent.create_child(src_entry.name, nil)
-              ui.output "Created #{dest_entry.path_for_printing}/"
-            end
-            # Directory creation is recursive.
-            if recurse_depth != 0
-              src_entry.children.each do |src_child|
-                new_dest_child = new_dest_dir.child(src_child.name)
-                copy_entries(src_child, new_dest_child, new_dest_dir, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui)
+            if src_entry.dir?
+              if options[:dry_run]
+                ui.output "Would create #{dest_path}"
+                new_dest_dir = new_dest_parent.child(src_entry.name)
+              else
+                new_dest_dir = new_dest_parent.create_child(src_entry.name, nil)
+                ui.output "Created #{dest_path}"
+              end
+              # Directory creation is recursive.
+              if recurse_depth != 0
+                src_entry.children.each do |src_child|
+                  new_dest_child = new_dest_dir.child(src_child.name)
+                  child_error = copy_entries(src_child, new_dest_child, new_dest_dir, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui, format_path)
+                  error ||= child_error
+                end
               end
-            end
-          else
-            if options[:dry_run]
-              ui.output "Would create #{dest_entry.path_for_printing}"
             else
-              new_dest_parent.create_child(src_entry.name, src_entry.read)
-              ui.output "Created #{dest_entry.path_for_printing}"
+              if options[:dry_run]
+                ui.output "Would create #{dest_path}"
+              else
+                new_dest_parent.create_child(src_entry.name, src_entry.read)
+                ui.output "Created #{dest_path}"
+              end
             end
           end
-        end
-
-      else
-        # Both exist.
 
-        # If the entry can do a copy directly, do that.
-        if dest_entry.respond_to?(:copy_from)
-          if options[:force] || compare(src_entry, dest_entry)[0] == false
-            if options[:dry_run]
-              ui.output "Would update #{dest_entry.path_for_printing}"
-            else
-              dest_entry.copy_from(src_entry)
-              ui.output "Updated #{dest_entry.path_for_printing}"
-            end
-          end
-          return
-        end
+        else
+          # Both exist.
 
-        # If they are different types, log an error.
-        if src_entry.dir?
-          if dest_entry.dir?
-            # If both are directories, recurse into their children
-            if recurse_depth != 0
-              child_pairs(src_entry, dest_entry).each do |src_child, dest_child|
-                copy_entries(src_child, dest_child, dest_entry, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui)
+          # If the entry can do a copy directly, do that.
+          if dest_entry.respond_to?(:copy_from)
+            if options[:force] || compare(src_entry, dest_entry)[0] == false
+              if options[:dry_run]
+                ui.output "Would update #{dest_path}"
+              else
+                dest_entry.copy_from(src_entry)
+                ui.output "Updated #{dest_path}"
               end
             end
-          else
-            # If they are different types.
-            ui.error("File #{dest_entry.path_for_printing} is a directory while file #{dest_entry.path_for_printing} is a regular file\n")
             return
           end
-        else
-          if dest_entry.dir?
-            ui.error("File #{dest_entry.path_for_printing} is a directory while file #{dest_entry.path_for_printing} is a regular file\n")
-            return
-          else
 
-            # Both are files!  Copy them unless we're sure they are the same.
-            if options[:force]
-              should_copy = true
-              src_value = nil
+          # If they are different types, log an error.
+          if src_entry.dir?
+            if dest_entry.dir?
+              # If both are directories, recurse into their children
+              if recurse_depth != 0
+                child_pairs(src_entry, dest_entry).each do |src_child, dest_child|
+                  child_error = copy_entries(src_child, dest_child, dest_entry, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui, format_path)
+                  error ||= child_error
+                end
+              end
             else
-              are_same, src_value, dest_value = compare(src_entry, dest_entry)
-              should_copy = !are_same
+              # If they are different types.
+              ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n")
+              return
             end
-            if should_copy
-              if options[:dry_run]
-                ui.output "Would update #{dest_entry.path_for_printing}"
+          else
+            if dest_entry.dir?
+              ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n")
+              return
+            else
+
+              # Both are files!  Copy them unless we're sure they are the same.
+              if options[:force]
+                should_copy = true
+                src_value = nil
               else
-                src_value = src_entry.read if src_value.nil?
-                dest_entry.write(src_value)
-                ui.output "Updated #{dest_entry.path_for_printing}"
+                are_same, src_value, dest_value = compare(src_entry, dest_entry)
+                should_copy = !are_same
+              end
+              if should_copy
+                if options[:dry_run]
+                  ui.output "Would update #{dest_path}"
+                else
+                  src_value = src_entry.read if src_value.nil?
+                  dest_entry.write(src_value)
+                  ui.output "Updated #{dest_path}"
+                end
               end
             end
           end
         end
+      rescue OperationSkippedError
+        # If it was simply skipped, a warning has already been printed.
+      rescue OperationNotAllowedError => e
+        ui.error e.message
+        error = true
       end
+      error
     end
 
-    def self.get_or_create_parent(entry, options, ui)
+    def self.get_or_create_parent(entry, options, ui, format_path)
       parent = entry.parent
       if parent && !parent.exists?
-        parent_parent = get_or_create_parent(entry.parent, options, ui)
+        parent_path = format_path.call(parent)
+        parent_parent = get_or_create_parent(entry.parent, options, ui, format_path)
         if options[:dry_run]
-          ui.output "Would create #{parent.path_for_printing}"
+          ui.output "Would create #{parent_path}"
         else
-          parent = parent_parent.create_child(parent.name, true)
-          ui.output "Created #{parent.path_for_printing}"
+          parent = parent_parent.create_child(parent.name, nil)
+          ui.output "Created #{parent_path}"
         end
       end
       return parent