knife-essentials 0.9.3 → 0.9.4

data/README.rdoc

@@ -116,6 +116,70 @@ work.  Use +--tree+ parameter to show this in a tree structure.  Use +--remote+
 to perform this operation against the data on the server rather than the local
 Chef repository.
 
+= CONFIGURATION
+
+There are several variables you can set in your +knife.rb+ file to alter the
+behavior of knife-essentials
+
+== chef_repo_path
+
+    chef_repo_path PATH|[PATH1, PATH2, ...]
+
+This is the path to the top of your chef repository.  Multiple paths are
+supported.  If you do not specify this, it defaults to +cookbook_path/..+ (for
+historical reasons, many knife.rb files contain +cookbook_path+.)
+
+If you specify this or +cookbook_path+, it is not necessary to specify the other paths (+client_path+,
++data_bag_path+, etc.).  They will be assumed to be under the chef_repo_path(s).
+
+== *_path
+
+    client_path PATH|[PATH1, PATH2, ...]
+    cookbook_path PATH|[PATH1, PATH2, ...]
+    data_bag_path PATH|[PATH1, PATH2, ...]
+    environment_path PATH|[PATH1, PATH2, ...]
+    node_path PATH|[PATH1, PATH2, ...]
+    role_path PATH|[PATH1, PATH2, ...]
+    user_path PATH|[PATH1, PATH2, ...]
+
+The local path where client json files, cookbook directories, etc. are stored.
+Each supports multiple paths, in which case all files/subdirectories from each
+path are merged into one virtual path (i.e. when you +knife list cookbooks+ it
+will show you a list including all cookbooks from all cookbook_paths).
+
+You generally do NOT need to specify these.  If you do not specify an _path
+variable, it is set to chef_repo_path/clients|cookbooks|data_bags|environments|nodes|roles|users.
+Each of these supports multiple paths.  If multiple paths are supported, and a
+new object is downloaded (say, a new cookbook), the object is downloaded into
+the *first* path in the list.  Updated objects stay where they are.
+
+== versioned_cookbooks
+
+    versioned_cookbooks true
+
+This option, when set to +true+, will cause knife-essentials to work with
+multiple versions of cookbooks.  In this case, your /cookbooks directory will
+have cookbook directory names of the form: +apache2-1.0.0+, +apache2-1.0.1+,
++mysql-1.1.2+, etc.  A full download of /cookbooks will download all versions,
+And a diff of a specific version will diff exactly that version and no other.
+
+This is super handy, especially combined with repo_mode "everything," as it will
+allow you to back up or restore a full copy of your Chef server.
+
+== repo_mode
+
+    repo_mode "everything"
+
+By default, knife-essentials only maps "cookbooks," "data_bags," environments," and "roles."  If you specify repo_mode "everything", it will map *everything* on the server,
+including users, clients and nodes.
+
+The author is not particularly happy about the necessity for this, and will try
+to get rid of it as soon as a way is found to avoid violating the Principle of
+Least Surprise.  The reason things are split this way is that most people don't
+store users, clients and nodes in source control.  +knife deps+ fares very
+poorly due to the way things are; but +knife diff+ gets surprising if it shows
+nodes, which aren't usually in your repo.
+
 == NOTE ABOUT WILDCARDS
 
 knife-essentials supports wildcards internally, and will use them to sift through objects

data/lib/chef/knife/raw_essentials.rb

@@ -1,10 +1,12 @@
 require 'json'
 require 'chef_fs/data_handler/data_handler_base'
+require 'chef_fs/file_system/base_fs_object'
 
 class Chef
   class Knife
     remove_const(:Raw) if const_defined?(:Raw) && Raw.name == 'Chef::Knife::Raw' # override Chef's version
     class Raw < Chef::Knife
+      ChefFS = ::ChefFS
       banner "knife raw REQUEST_PATH"
 
       option :method,
@@ -42,7 +44,7 @@ class Chef
         end
         chef_rest = Chef::REST.new(Chef::Config[:chef_server_url])
         begin
-          output ChefFS::FileSystem::BaseFSObject.api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
+          output ::ChefFS::FileSystem::BaseFSObject.api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
         rescue Net::HTTPServerException => e
           ui.error "Server responded with error #{e.response.code} \"#{e.response.message}\""
           ui.error "Error Body: #{e.response.body}" if e.response.body && e.response.body != ''

data/lib/chef_fs/file_system/rest_list_dir.rb

@@ -51,7 +51,7 @@ module ChefFS
           if $!.response.code == "404"
             raise ChefFS::FileSystem::NotFoundError.new(self, $!)
           else
-            raise ChefFS::FileSystem::OperationFailedError.new(:children, self, e)
+            raise ChefFS::FileSystem::OperationFailedError.new(:children, self, e), "HTTP error retrieving children: #{e}"
           end
         end
       end

data/lib/chef_fs/knife.rb

@@ -27,79 +27,78 @@ module ChefFS
     def self.common_options
       option :repo_mode,
         :long => '--repo-mode MODE',
-        :default => "default",
-        :description => "Specifies the local repository layout.  Values: default or full"
+        :description => "Specifies the local repository layout.  Values: default or everything"
 
       option :chef_repo_path,
         :long => '--chef-repo-path PATH',
-        :default => nil,
-        :description => 'Overrides the location of chef repo. Default is specified by chef_repo_paths in the config'
+        :description => 'Overrides the location of chef repo. Default is specified by chef_repo_path in the config'
     end
 
-    def chef_fs
-      @chef_fs ||= ChefFS::FileSystem::ChefServerRootDir.new("remote", Chef::Config, config[:repo_mode])
-    end
+    def configure_chef
+      super
+      Chef::Config[:repo_mode] = config[:repo_mode] if config[:repo_mode]
 
-    def chef_repo_paths
-      @chef_repo_paths ||= begin
-                             result = config_paths(:chef_repo_path)
-                             if result
-                               result
-                             else
-                               if Chef::Config[:cookbook_path]
-                                 Array(Chef::Config[:cookbook_path]).flatten.map { |path| File.expand_path('..', path) }
-                               else
-                                 nil
-                               end
-                             end
+      # --chef-repo-path overrides all other paths
+      path_variables = %w(client_path cookbook_path data_bag_path environment_path node_path role_path user_path)
+      if config[:chef_repo_path]
+        Chef::Config[:chef_repo_path] = config[:chef_repo_path]
+        path_variables.each do |variable_name|
+          Chef::Config[variable_name.to_sym] = nil
+        end
+      end
+
+      # Infer chef_repo_path from cookbook_path if not speciifed
+      if !Chef::Config[:chef_repo_path]
+        if Chef::Config[:cookbook_path]
+          Chef::Config[:chef_repo_path] = Array(Chef::Config[:cookbook_path]).flatten.map { |path| File.expand_path('..', path) }
+        end
       end
-    end
 
-    # Smooth out some inappropriate (for now) variable defaults in Chef.
-    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]
-      else
-        Chef::Config[name]
+      # Smooth out some (for now) inappropriate defaults set by Chef
+      if Chef::Config[:data_bag_path] == Chef::Config.platform_specific_path('/var/chef/data_bags')
+        Chef::Config[:data_bag_path] = nil
+      end
+      if Chef::Config[:node_path] == '/var/chef/node'
+        Chef::Config[:node_path] = nil
       end
-      if result
-        Array(result).flatten
-      else
-        nil
+      if Chef::Config[:role_path] == Chef::Config.platform_specific_path('/var/chef/roles')
+        Chef::Config[:role_path] = nil
       end
+
+      # Infer any *_path variables that are not specified
+      if Chef::Config[:chef_repo_path]
+        path_variables.each do |variable_name|
+          chef_repo_paths = Array(Chef::Config[:chef_repo_path]).flatten
+          variable = variable_name.to_sym
+          if !Chef::Config[variable]
+            # cookbook_path -> cookbooks
+            Chef::Config[variable] = chef_repo_paths.map { |path| File.join(path, "#{variable_name[0..-6]}s") }
+          end
+        end
+      end
+    end
+
+    def chef_fs
+      @chef_fs ||= ChefFS::FileSystem::ChefServerRootDir.new("remote", Chef::Config, Chef::Config[:repo_mode])
     end
 
     def object_paths
       @object_paths ||= begin
+        if !Chef::Config[:chef_repo_path]
+          Chef::Log.error("Must specify either chef_repo_path or cookbook_path in Chef config file")
+          exit(1)
+        end
+
         result = {}
-        if config[:repo_mode] == 'everything'
+        if Chef::Config[:repo_mode] == 'everything'
           object_names = %w(clients cookbooks data_bags environments nodes roles users)
         else
           object_names = %w(cookbooks data_bags environments roles)
         end
         object_names.each do |object_name|
-          # If --chef-repo-path is passed in the command line, then override *everything*
-          # and assume all the subdirectory is contained in that directory.
-          if config[:chef_repo_path]
-            paths = [ "#{config[:chef_repo_path]}/#{object_name}" ]
-          else
-            variable_name = "#{object_name[0..-2]}_path" # cookbooks -> cookbook_path
-            paths = config_paths(variable_name.to_sym)
-            if !paths
-              if !chef_repo_paths
-                Chef::Log.error("Must specify either chef_repo_path or #{variable_name} in Chef config file")
-                exit(1)
-              end
-              paths = chef_repo_paths.map { |path| File.join(path, object_name) }
-            end
-          end
-          paths = paths.flatten.map { |path| File.expand_path(path) }
-          result[object_name] = paths
+          variable_name = "#{object_name[0..-2]}_path" # cookbooks -> cookbook_path
+          paths = Array(Chef::Config[variable_name]).flatten
+          result[object_name] = paths.map { |path| File.expand_path(path) }
         end
         result
       end
@@ -143,7 +142,7 @@ module ChefFS
       end
 
       # Check chef_repo_path
-      chef_repo_paths.each do |chef_repo_path|
+      Array(Chef::Config[:chef_repo_path]).flatten.each do |chef_repo_path|
         realest_chef_repo_path = ChefFS::PathUtils.realest_path(chef_repo_path)
         if absolute_path == realest_chef_repo_path
           return '/'

data/lib/chef_fs/version.rb

@@ -1,3 +1,3 @@
 module ChefFS
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-essentials
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 Z
+date: 2013-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-zero