knife-essentials 0.2.1 → 0.3

data/README.rdoc

@@ -7,6 +7,7 @@ to manipulate Chef using a common set of verbs that work on *everything*
 that is stored in the Chef server.
 
    knife diff cookbooks/*apache*
+   knife download roles data_bags cookbooks/emacs
    knife list data_bags/users
    knife show roles/*base*
 
@@ -53,6 +54,7 @@ This plugin builds a Ruby Gem (but has not yet been released to RubyGems).  To i
 chef_fs installs a number of useful knife verbs, including:
 
     knife diff [pattern1 pattern2 ...]
+    knife download [pattern1 pattern2 ...]
     knife list [pattern1 pattern2 ...]
     knife show [pattern2 pattern2 ...]
 
@@ -81,6 +83,13 @@ To run the knife plugin functionality, install a version of Chef > 0.10.10:
 Diffs objects on the server against files in the local repository.  Output is similar to
 +git diff+.
 
+== knife download
+
+    knife download [pattern1 pattern2 ...]
+
+Downloads objects from the server to your local repository.  Pass --purge to delete local
+files and directories which do not exist on the server.
+
 == knife list
 
     knife list [pattern1 pattern2 ...]

data/lib/chef/knife/download.rb

@@ -0,0 +1,32 @@
+require 'chef_fs/knife'
+require 'chef_fs/command_line'
+
+class Chef
+  class Knife
+    class Download < ChefFS::Knife
+      banner "download PATTERNS"
+
+      option :recurse,
+        :long => '--[no-]recurse',
+        :boolean => true,
+        :default => true,
+        :description => "List directories recursively."
+
+      option :purge,
+        :long => '--[no-]purge',
+        :boolean => true,
+        :default => false,
+        :description => "Delete matching local files and directories that do not exist remotely."
+
+      def run
+        patterns = pattern_args_from(name_args.length > 0 ? name_args : [ "" ])
+
+        # Get the matches (recursively)
+        patterns.each do |pattern|
+          ChefFS::FileSystem.copy_to(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, config[:purge])
+        end
+      end
+    end
+  end
+end
+

data/lib/chef_fs/diff.rb

@@ -12,7 +12,7 @@ module ChefFS
       Digest::MD5.hexdigest(value)
     end
 
-    def self.diff_files(old_file, new_file)
+    def self.diff_files_quick(old_file, new_file)
       #
       # Short-circuit expensive comparison (could be an extra network
       # request) if a pre-calculated checksum is there
@@ -42,7 +42,16 @@ module ChefFS
         end
 
         # If the checksums are the same, they are the same.  Return.
-        return false if old_checksum == new_checksum
+        return [ false, old_value, new_value ] if old_checksum == new_checksum
+      end
+
+      return [ nil, old_value, new_value ]
+    end
+
+    def self.diff_files(old_file, new_file)
+      different, old_value, new_value = diff_files_quick(old_file, new_file)
+      if different != nil
+        return different
       end
 
       #
@@ -87,8 +96,8 @@ module ChefFS
       ChefFS::FileSystem.list(a_root, pattern) do |a|
         found_paths << a.path
         b = ChefFS::FileSystem.resolve_path(b_root, a.path)
-        diffable_leaves(a, b, recurse_depth) do |a_leaf, b_leaf|
-          yield [ a_leaf, b_leaf ]
+        diffable_leaves(a, b, recurse_depth) do |a_leaf, b_leaf, leaf_recurse_depth|
+          yield [ a_leaf, b_leaf, leaf_recurse_depth ]
         end
       end
 
@@ -97,7 +106,7 @@ module ChefFS
       ChefFS::FileSystem.list(b_root, pattern) do |b|
         if !found_paths.include?(b.path)
           a = ChefFS::FileSystem.resolve_path(a_root, b.path)
-          yield [ a, b ]
+          yield [ a, b, recurse_depth ]
         end
       end
     end
@@ -126,15 +135,15 @@ module ChefFS
         a_children_names = Set.new
         a.children.each do |a_child|
           a_children_names << a_child.name
-          diffable_leaves(a_child, b.child(a_child.name), recurse_depth ? recurse_depth - 1 : nil) do |a_leaf, b_leaf|
-            yield [ a_leaf, b_leaf ]
+          diffable_leaves(a_child, b.child(a_child.name), recurse_depth ? recurse_depth - 1 : nil) do |a_leaf, b_leaf, leaf_recurse_depth|
+            yield [ a_leaf, b_leaf, leaf_recurse_depth ]
           end
         end
 
         # Check b for children that aren't in a
         b.children.each do |b_child|
           if !a_children_names.include?(b_child.name)
-            yield [ a.child(b_child.name), b_child ]
+            yield [ a.child(b_child.name), b_child, recurse_depth ]
           end
         end
         return

data/lib/chef_fs/file_system.rb

@@ -1,7 +1,12 @@
 require 'chef_fs/path_utils'
+require 'chef_fs/diff'
 
 module ChefFS
   module FileSystem
+    def self.copy_to(pattern, src_root, dest_root)
+
+    end
+
     # Yields a list of all things under (and including) this entry that match the
     # given pattern.
     #
@@ -64,6 +69,109 @@ module ChefFS
       end
       result
     end
+
+    # Copy everything matching the given pattern from src to dest.
+    #
+    # After this method completes, everything in dest matching the
+    # given pattern will look identical to src.
+    #
+    # ==== Attributes
+    # 
+    # * +pattern+ - ChefFS::FilePattern to match children under
+    # * +src_root+ - the root from which things will be copied
+    # * +dest_root+ - the root to which things will be copied
+    # * +recurse_depth+ - the maximum depth to copy things. +nil+
+    #   means infinite depth.  0 means no recursion.
+    # * +purge+ - if +true+, items in +dest+ that are not in +src+
+    #   will be deleted from +dest+.  If +false+, these items will
+    #   be left alone.
+    #
+    # ==== Examples
+    #
+    #     ChefFS::FileSystem.copy_to(FilePattern.new('/cookbooks', chef_fs, local_fs, nil, true)
+    #
+    def self.copy_to(pattern, src_root, dest_root, recurse_depth, purge)
+      found_result = false
+      # Find things we might want to copy
+      ChefFS::Diff::diffable_leaves_from_pattern(pattern, src_root, dest_root, recurse_depth) do |src_leaf, dest_leaf, child_recurse_depth|
+        found_result = true
+        copy_leaves(src_leaf, dest_leaf, child_recurse_depth, purge)
+      end
+      if !found_result && pattern.exact_path
+        yield "#{pattern}: No such file or directory on remote or local"
+      end
+    end
+
+    private
+
+    # Copy two known leaves (could be files or dirs)
+    def self.copy_leaves(src_entry, dest_entry, recurse_depth, purge)
+      # 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
+      # exists (a "dir" in the parent) before deciding whether to POST or
+      # PUT it.  If we just tried PUT (or POST) and then tried the other if
+      # the conflict failed, we wouldn't need to check existence.
+      # On the other hand, we may already have DONE the request, in which
+      # case we shouldn't waste time trying PUT if we know the file doesn't
+      # exist.
+      # Will need to decide how that works with checksums, though.
+
+      if !src_entry.exists?
+        if 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?)
+            Chef::Log.info("Deleting extra entry #{dest_entry.path_for_printing} (purge is on)")
+            dest_entry.delete
+          end
+        end
+
+      elsif !dest_entry.exists?
+        if dest_entry.parent.can_have_child?(src_entry.name, src_entry.dir?)
+          if src_entry.dir?
+            Chef::Log.info("Creating #{dest_entry.path_for_printing}/")
+            new_dest_dir = dest_entry.parent.create_child(src_entry.name, nil)
+            # 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_leaves(src_child, new_dest_child, recurse_depth ? recurse_depth - 1 : recurse_depth, purge)
+              end
+            end
+          else
+            Chef::Log.info("Creating #{dest_entry.path_for_printing}")
+            dest_entry.parent.create_child(src_entry.name, src_entry.read)
+          end
+        end
+
+      else
+        # Both exist.
+        # If they are different types, log an error.
+        if src_entry.dir?
+          if dest_entry.dir?
+            # If they are both directories, we'll end up recursing later.
+          else
+            # If they are different types.
+            Chef::Log.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?
+            Chef::Log.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.
+            different, src_value, dest_value = ChefFS::Diff.diff_files_quick(src_entry, dest_entry)
+            if different || different == nil
+              Chef::Log.info("Copying #{src_entry.path_for_printing} to #{dest_entry.path_for_printing}")
+              src_value = src_entry.read if src_value == :not_retrieved
+              dest_entry.write(src_value)
+            end
+          end
+        end
+      end
+    end
+
   end
 end
 

data/lib/chef_fs/file_system/file_system_entry.rb

@@ -2,6 +2,7 @@ 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'
+require 'fileutils'
 
 module ChefFS
   module FileSystem
@@ -18,18 +19,46 @@ module ChefFS
       end
 
       def children
-        @children ||= Dir.entries(file_path).select { |entry| entry != '.' && entry != '..' }.map { |entry| FileSystemEntry.new(entry, self) }
+        begin
+          @children ||= Dir.entries(file_path).select { |entry| entry != '.' && entry != '..' }.map { |entry| FileSystemEntry.new(entry, self) }
+        rescue Errno::ENOENT
+          raise ChefFS::FileSystem::NotFoundError.new($!), "#{file_path} not found"
+        end
+      end
+
+      def create_child(child_name, file_contents=nil)
+        result = FileSystemEntry.new(child_name, self)
+        if file_contents
+          result.write(file_contents)
+        else
+          Dir.mkdir(result.file_path)
+        end
+        result
       end
 
       def dir?
         File.directory?(file_path)
       end
 
+      def delete
+        if dir?
+          FileUtils.rm_rf(file_path)
+        else
+          File.delete(file_path)
+        end
+      end
+
       def read
         begin
           IO.read(file_path)
-        rescue IONotFoundError # TODO real exception
-          raise ChefFS::FileSystem::NotFoundError.new($!), "#{path_for_printing} not found"
+        rescue Errno::ENOENT
+          raise ChefFS::FileSystem::NotFoundError.new($!), "#{file_path} not found"
+        end
+      end
+
+      def write(content)
+        File.open(file_path, 'w') do |file|
+          file.write(content)
         end
       end
     end

data/lib/chef_fs/version.rb

@@ -1,4 +1,4 @@
 module ChefFS
-  VERSION = "0.2.1"
+  VERSION = "0.3"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-essentials
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: '0.3'
   prerelease: 
 platform: ruby
 authors:
@@ -23,6 +23,7 @@ files:
 - README.rdoc
 - Rakefile
 - lib/chef/knife/diff.rb
+- lib/chef/knife/download.rb
 - lib/chef/knife/list.rb
 - lib/chef/knife/show.rb
 - lib/chef_fs/command_line.rb