knife-essentials 1.0.0 → 1.1

data/lib/chef/knife/raw_essentials.rb

@@ -45,6 +45,9 @@ class Chef
         chef_rest = Chef::REST.new(Chef::Config[:chef_server_url])
         begin
           output ChefFS::RawRequest.api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
+        rescue Timeout::Error => e
+          ui.error "Server timeout"
+          exit 1
         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/knife/serve_essentials.rb

@@ -0,0 +1,397 @@
+require 'chef_fs/knife'
+require 'chef_zero/server'
+require 'chef_zero/data_store/memory_store'
+
+# For ChefFSStore
+require 'chef_fs/file_pattern'
+require 'chef_fs/file_system'
+require 'chef_fs/file_system/not_found_error'
+require 'chef_fs/file_system/memory_root'
+require 'chef_zero/data_store/data_already_exists_error'
+require 'chef_zero/data_store/data_not_found_error'
+
+class Chef
+  class Knife
+    remove_const(:Serve) if const_defined?(:Serve) && Serve.name == 'Chef::Knife::Serve' # override Chef's version
+    class Serve < ::ChefFS::Knife
+      ChefFS = ::ChefFS
+      banner "knife show [PATTERN1 ... PATTERNn]"
+
+      common_options
+
+      option :remote,
+        :long => '--remote',
+        :boolean => true,
+        :description => "Proxy the remote server instead of the local filesystem"
+
+      option :host,
+        :short => '-H',
+        :long => '--host=HOST',
+        :description => "Host to bind to (default: 127.0.0.1)"
+
+      option :port,
+        :short => '-p',
+        :long => '--port=PORT',
+        :description => "Port to listen on (default: 4000)"
+
+      option :generate_real_keys,
+        :long => '--[no-]generate-keys',
+        :boolean => true,
+        :description => "Whether to generate actual keys or fake it (faster).  Default: false."
+
+      def run
+        server_options = {}
+        server_options[:data_store] = ChefFSDataStore.new(proc { config[:remote] ? create_chef_fs : create_local_fs })
+        server_options[:log_level] = Chef::Log.level
+        server_options[:host] = config[:host] if config[:host]
+        server_options[:port] = config[:port] ? config[:port].to_i : 4000
+        server_options[:generate_real_keys] = config[:generate_real_keys] if config[:generate_real_keys]
+
+        ChefZero::Server.new(server_options).start(:publish => true)
+      end
+
+      class ChefFSDataStore
+        def initialize(chef_fs)
+          @chef_fs = chef_fs
+          @memory_store = ChefZero::DataStore::MemoryStore.new
+        end
+
+        def chef_fs
+          @chef_fs.call
+        end
+
+        MEMORY_PATHS = %w(sandboxes file_store)
+
+        def create_dir(path, name, *options)
+          if use_memory_store?(path)
+            @memory_store.create_dir(path, name, *options)
+          else
+            with_dir(path) do |parent|
+              parent.create_child(chef_fs_filename(path + [name]), nil)
+            end
+          end
+        end
+
+        def create(path, name, data, *options)
+          if use_memory_store?(path)
+            @memory_store.create(path, name, data, *options)
+
+          elsif path[0] == 'cookbooks' && path.length == 2
+            # Do nothing.  The entry gets created when the cookbook is created.
+
+          else
+            if !data.is_a?(String)
+              raise "set only works with strings"
+            end
+
+            with_dir(path) do |parent|
+              parent.create_child(chef_fs_filename(path + [name]), data)
+            end
+          end
+        end
+
+        def get(path, request=nil)
+          if use_memory_store?(path)
+            @memory_store.get(path)
+
+          elsif path[0] == 'file_store' && path[1] == 'repo'
+            entry = ChefFS::FileSystem.resolve_path(chef_fs, path[2..-1].join('/'))
+            begin
+              entry.read
+            rescue ChefFS::FileSystem::NotFoundError => e
+              raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
+            end
+
+          else
+            with_entry(path) do |entry|
+              if path[0] == 'cookbooks' && path.length == 3
+                # get /cookbooks/NAME/version
+                result = entry.chef_object.to_hash
+                result.each_pair do |key, value|
+                  if value.is_a?(Array)
+                    value.each do |file|
+                      if file.is_a?(Hash) && file.has_key?('checksum')
+                        relative = ['file_store', 'repo', 'cookbooks']
+                        if Chef::Config.versioned_cookbooks
+                          relative << "#{path[1]}-#{path[2]}"
+                        else
+                          relative << path[1]
+                        end
+                        relative = relative + file[:path].split('/')
+                        file['url'] = ChefZero::RestBase::build_uri(request.base_uri, relative)
+                      end
+                    end
+                  end
+                end
+                JSON.pretty_generate(result)
+
+              else
+                entry.read
+              end
+            end
+          end
+        end
+
+        def set(path, data, *options)
+          if use_memory_store?(path)
+            @memory_store.set(path, data, *options)
+          else
+            if !data.is_a?(String)
+              raise "set only works with strings: #{path} = #{data.inspect}"
+            end
+
+            # Write out the files!
+            if path[0] == 'cookbooks' && path.length == 3
+              write_cookbook(path, data, *options)
+            else
+              with_dir(path[0..-2]) do |parent|
+                parent.create_child(chef_fs_filename(path), data)
+              end
+            end
+          end
+        end
+
+        def delete(path)
+          if use_memory_store?(path)
+            @memory_store.delete(path)
+          else
+            with_entry(path) do |entry|
+              if path[0] == 'cookbooks' && path.length >= 3
+                entry.delete(true)
+              else
+                entry.delete
+              end
+            end
+          end
+        end
+
+        def delete_dir(path, *options)
+          if use_memory_store?(path)
+            @memory_store.delete_dir(path, *options)
+          else
+            with_entry(path) do |entry|
+              entry.delete(options.include?(:recursive))
+            end
+          end
+        end
+
+        def list(path)
+          if use_memory_store?(path)
+            @memory_store.list(path)
+
+          elsif path[0] == 'cookbooks' && path.length == 1
+            with_entry(path) do |entry|
+              begin
+                if Chef::Config.versioned_cookbooks
+                  # /cookbooks/name-version -> /cookbooks/name
+                  entry.children.map { |child| split_name_version(child.name)[0] }.uniq
+                else
+                  entry.children.map { |child| child.name }
+                end
+              rescue ChefFS::FileSystem::NotFoundError
+                # If the cookbooks dir doesn't exist, we have no cookbooks (not 404)
+                []
+              end
+            end
+
+          elsif path[0] == 'cookbooks' && path.length == 2
+            if Chef::Config.versioned_cookbooks
+              # list /cookbooks/name = filter /cookbooks/name-version down to name
+              entry.children.map { |child| split_name_version(child.name) }.
+                             select { |name, version| name == path[1] }.
+                             map { |name, version| version }.to_a
+            else
+              # list /cookbooks/name = <single version>
+              version = get_single_cookbook_version(path)
+              [version]
+            end
+
+          else
+            with_entry(path) do |entry|
+              begin
+                entry.children.map { |c| zero_filename(c) }.sort
+              rescue ChefFS::FileSystem::NotFoundError
+                # /cookbooks, /data, etc. never return 404
+                if path_always_exists?(path)
+                  []
+                else
+                  raise
+                end
+              end
+            end
+          end
+        end
+
+        def exists?(path)
+          if use_memory_store?(path)
+            @memory_store.exists?(path)
+          else
+            path_always_exists?(path) || ChefFS::FileSystem.resolve_path(chef_fs, to_chef_fs_path(path)).exists?
+          end
+        end
+
+        def exists_dir?(path)
+          if use_memory_store?(path)
+            @memory_store.exists_dir?(path)
+          elsif path[0] == 'cookbooks' && path.length == 2
+            list([ path[0] ]).include?(path[1])
+          else
+            ChefFS::FileSystem.resolve_path(chef_fs, to_chef_fs_path(path)).exists?
+          end
+        end
+
+        private
+
+        def use_memory_store?(path)
+          return path[0] == 'sandboxes' || path[0] == 'file_store' && path[1] == 'checksums' || path == [ 'environments', '_default' ]
+        end
+
+        def write_cookbook(path, data, *options)
+          # Create a little ChefFS memory filesystem with the data
+          if Chef::Config.versioned_cookbooks
+            cookbook_path = "cookbooks/#{path[1]}-#{path[2]}"
+          else
+            cookbook_path = "cookbooks/#{path[1]}"
+          end
+          puts "Write cookbook #{cookbook_path}"
+          cookbook_fs = ChefFS::FileSystem::MemoryRoot.new('uploading')
+          cookbook = JSON.parse(data, :create_additions => false)
+          cookbook.each_pair do |key, value|
+            if value.is_a?(Array)
+              value.each do |file|
+                if file.is_a?(Hash) && file.has_key?('checksum')
+                  file_data = @memory_store.get(['file_store', 'checksums', file['checksum']])
+                  cookbook_fs.add_file("#{cookbook_path}/#{file['path']}", file_data)
+                end
+              end
+            end
+          end
+
+          # Use the copy/diff algorithm to copy it down so we don't destroy
+          # chefignored data.  This is terribly un-thread-safe.
+          ChefFS::FileSystem.copy_to(ChefFS::FilePattern.new("/#{cookbook_path}"), cookbook_fs, chef_fs, nil, {:purge => true})
+        end
+
+        def split_name_version(entry_name)
+          name_version = entry_name.split('-')
+          name = name_version[0..-2].join('-')
+          version = name_version[-1]
+          [name,version]
+        end
+
+        def to_chef_fs_path(path)
+          _to_chef_fs_path(path).join('/')
+        end
+
+        def chef_fs_filename(path)
+          _to_chef_fs_path(path)[-1]
+        end
+
+        def _to_chef_fs_path(path)
+          if path[0] == 'data'
+            path = path.dup
+            path[0] = 'data_bags'
+            if path.length >= 3
+              path[2] = "#{path[2]}.json"
+            end
+          elsif path[0] == 'cookbooks'
+            if path.length == 2
+              raise ChefZero::DataStore::DataNotFoundError.new(path)
+            elsif Chef::Config.versioned_cookbooks
+              if path.length >= 3
+                # cookbooks/name/version -> cookbooks/name-version
+                path = [ path[0], "#{path[1]}-#{path[2]}" ] + path[3..-1]
+              end
+            else
+              if path.length >= 3
+                # cookbooks/name/version/... -> /cookbooks/name/... iff metadata says so
+                version = get_single_cookbook_version(path)
+                if path[2] == version
+                  path = path[0..1] + path[3..-1]
+                else
+                  raise ChefZero::DataStore::DataNotFoundError.new(path)
+                end
+              end
+            end
+          elsif path.length == 2
+            path = path.dup
+            path[1] = "#{path[1]}.json"
+          end
+          path
+        end
+
+        def to_zero_path(entry)
+          path = entry.path.split('/')[1..-1]
+          if path[0] == 'data_bags'
+            path = path.dup
+            path[0] = 'data'
+            if path.length >= 3
+              path[2] = path[2][0..-6]
+            end
+
+          elsif path[0] == 'cookbooks'
+            if Chef::Config.versioned_cookbooks
+              # cookbooks/name-version/... -> cookbooks/name/version/...
+              if path.length >= 2
+                name, version = split_name_version(path[1])
+                path = [ path[0], name, version ] + path[2..-1]
+              end
+            else
+              if path.length >= 2
+                # cookbooks/name/... -> cookbooks/name/version/...
+                version = get_single_cookbook_version(path)
+                path = path[0..1] + [version] + path[2..-1]
+              end
+            end
+
+          elsif path.length == 2 && path[0] != 'cookbooks'
+            path = path.dup
+            path[1] = path[1][0..-6]
+          end
+          path
+        end
+
+        def zero_filename(entry)
+          to_zero_path(entry)[-1]
+        end
+
+        def path_always_exists?(path)
+          return path.length == 1 && %w(clients cookbooks data environments nodes roles users).include?(path[0])
+        end
+
+        def with_entry(path)
+          begin
+            yield ChefFS::FileSystem.resolve_path(chef_fs, to_chef_fs_path(path))
+          rescue ChefFS::FileSystem::NotFoundError => e
+            raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
+          end
+        end
+
+        def with_dir(path)
+          begin
+            yield get_dir(_to_chef_fs_path(path), true)
+          rescue ChefFS::FileSystem::NotFoundError => e
+            raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
+          end
+        end
+
+        def get_dir(path, create=false)
+          result = ChefFS::FileSystem.resolve_path(chef_fs, path.join('/'))
+          if result.exists?
+            result
+          elsif create
+            get_dir(path[0..-2], create).create_child(result.name, nil)
+          else
+            raise ChefZero::DataStore::DataNotFoundError.new(path)
+          end
+        end
+
+        def get_single_cookbook_version(path)
+          dir = ChefFS::FileSystem.resolve_path(chef_fs, path[0..1].join('/'))
+          metadata = ChefZero::CookbookData.metadata_from(dir, path[1], nil, [])
+          metadata[:version] || '0.0.0'
+        end
+      end
+    end
+  end
+end

data/lib/chef_fs/command_line.rb

@@ -90,6 +90,7 @@ module ChefFS
           else
             yield "Only in #{format_path.call(new_entry.parent)}: #{new_entry.name}\n"
           end
+
         when :modified
           next if diff_filter && diff_filter !~ /M/
           if output_mode == :name_only
@@ -101,6 +102,7 @@ module ChefFS
             result << diff_text(old_path, new_path, old_value, new_value)
             yield result
           end
+
         when :both_nonexistent
         when :added_cannot_upload
         when :deleted_cannot_download
@@ -232,23 +234,6 @@ module ChefFS
       return [ [ :error, old_entry, new_entry, nil, nil, e ] ]
     end
 
-    class Differ
-      def initialize(old_entry, new_entry, recurse_depth, get_content)
-        @old_entry = old_entry
-        @new_entry = new_entry
-        @recurse_depth = recurse_depth
-        @get_content = get_content
-      end
-
-      attr_reader :old_entry
-      attr_reader :new_entry
-      attr_reader :recurse_depth
-      attr_reader :get_content
-
-      def each
-      end
-    end
-
     private
 
     def self.sort_keys(json_object)

data/lib/chef_fs/file_system.rb

@@ -135,7 +135,7 @@ module ChefFS
     #       puts message
     #     end
     #
-    def self.copy_to(pattern, src_root, dest_root, recurse_depth, options, ui, format_path)
+    def self.copy_to(pattern, src_root, dest_root, recurse_depth, options, ui = nil, format_path = nil)
       found_result = false
       error = false
       parallel_do(list_pairs(pattern, src_root, dest_root)) do |src, dest|
@@ -145,7 +145,7 @@ module ChefFS
         error ||= child_error
       end
       if !found_result && pattern.exact_path
-        ui.error "#{pattern}: No such file or directory on remote or local"
+        ui.error "#{pattern}: No such file or directory on remote or local" if ui
         error = true
       end
       error
@@ -275,20 +275,20 @@ module ChefFS
 
       error = false
       begin
-        dest_path = format_path.call(dest_entry)
-        src_path = format_path.call(src_entry)
+        dest_path = format_path.call(dest_entry) if ui
+        src_path = format_path.call(src_entry) if ui
         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}"
+                ui.output "Would delete #{dest_path}" if ui
               else
                 dest_entry.delete(true)
-                ui.output "Deleted extra entry #{dest_path} (purge is on)"
+                ui.output "Deleted extra entry #{dest_path} (purge is on)" if ui
               end
             else
-              Chef::Log.info("Not deleting extra entry #{dest_path} (purge is off)")
+              Chef::Log.info("Not deleting extra entry #{dest_path} (purge is off)") if ui
             end
           end
 
@@ -297,21 +297,21 @@ module ChefFS
             # 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}"
+                ui.output "Would create #{dest_path}" if ui
               else
                 new_dest_parent.create_child_from(src_entry)
-                ui.output "Created #{dest_path}"
+                ui.output "Created #{dest_path}" if ui
               end
               return
             end
 
             if src_entry.dir?
               if options[:dry_run]
-                ui.output "Would create #{dest_path}"
+                ui.output "Would create #{dest_path}" if ui
                 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}"
+                ui.output "Created #{dest_path}" if ui
               end
               # Directory creation is recursive.
               if recurse_depth != 0
@@ -323,10 +323,10 @@ module ChefFS
               end
             else
               if options[:dry_run]
-                ui.output "Would create #{dest_path}"
+                ui.output "Would create #{dest_path}" if ui
               else
                 new_dest_parent.create_child(src_entry.name, src_entry.read)
-                ui.output "Created #{dest_path}"
+                ui.output "Created #{dest_path}" if ui
               end
             end
           end
@@ -338,10 +338,10 @@ module ChefFS
           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}"
+                ui.output "Would update #{dest_path}" if ui
               else
                 dest_entry.copy_from(src_entry)
-                ui.output "Updated #{dest_path}"
+                ui.output "Updated #{dest_path}" if ui
               end
             end
             return
@@ -359,12 +359,12 @@ module ChefFS
               end
             else
               # If they are different types.
-              ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n")
+              ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n") if ui
               return
             end
           else
             if dest_entry.dir?
-              ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n")
+              ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n") if ui
               return
             else
 
@@ -380,23 +380,23 @@ module ChefFS
               end
               if should_copy
                 if options[:dry_run]
-                  ui.output "Would update #{dest_path}"
+                  ui.output "Would update #{dest_path}" if ui
                 else
                   src_value = src_entry.read if src_value.nil?
                   dest_entry.write(src_value)
-                  ui.output "Updated #{dest_path}"
+                  ui.output "Updated #{dest_path}" if ui
                 end
               end
             end
           end
         end
       rescue DefaultEnvironmentCannotBeModifiedError => e
-        ui.warn "#{format_path.call(e.entry)} #{e.reason}."
+        ui.warn "#{format_path.call(e.entry)} #{e.reason}." if ui
       rescue OperationFailedError => e
-        ui.error "#{format_path.call(e.entry)} failed to #{e.operation}: #{e.message}"
+        ui.error "#{format_path.call(e.entry)} failed to #{e.operation}: #{e.message}" if ui
         error = true
       rescue OperationNotAllowedError => e
-        ui.error "#{format_path.call(e.entry)} #{e.reason}."
+        ui.error "#{format_path.call(e.entry)} #{e.reason}." if ui
         error = true
       end
       error
@@ -405,13 +405,13 @@ module ChefFS
     def self.get_or_create_parent(entry, options, ui, format_path)
       parent = entry.parent
       if parent && !parent.exists?
-        parent_path = format_path.call(parent)
+        parent_path = format_path.call(parent) if ui
         parent_parent = get_or_create_parent(entry.parent, options, ui, format_path)
         if options[:dry_run]
-          ui.output "Would create #{parent_path}"
+          ui.output "Would create #{parent_path}" if ui
         else
           parent = parent_parent.create_child(parent.name, nil)
-          ui.output "Created #{parent_path}"
+          ui.output "Created #{parent_path}" if ui
         end
       end
       return parent

data/lib/chef_fs/file_system/acl_entry.rb

@@ -40,6 +40,8 @@ module ChefFS
         PERMISSIONS.each do |permission|
           begin
             rest.put_rest("#{api_path}/#{permission}", { permission => acls[permission] })
+          rescue Timeout::Error => e
+            raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Timeout writing: #{e}"
           rescue Net::HTTPServerException => e
             if e.response.code == "404"
               raise ChefFS::FileSystem::NotFoundError.new(self, e)

data/lib/chef_fs/file_system/cookbook_dir.rb

@@ -125,9 +125,13 @@ module ChefFS
         if recurse
           begin
             rest.delete_rest(api_path)
+          rescue Timeout::Error => e
+            raise ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "Timeout deleting: #{e}"
           rescue Net::HTTPServerException
             if $!.response.code == "404"
               raise ChefFS::FileSystem::NotFoundError.new(self, $!)
+            else
+              raise ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "HTTP error deleting: #{e}"
             end
           end
         else
@@ -189,22 +193,26 @@ module ChefFS
           ensure
             Chef::Config[:http_retry_count] = old_retry_count
           end
-        rescue Net::HTTPServerException
-          if $!.response.code == "404"
-            @could_not_get_chef_object = $!
+
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "Timeout reading: #{e}"
+
+        rescue Net::HTTPServerException => e
+          if e.response.code == "404"
+            @could_not_get_chef_object = e
             raise ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
           else
-            raise
+            raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
           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_chef_object = $!
+        rescue Net::HTTPFatalError => e
+          if e.response.code == "500"
+            @could_not_get_chef_object = e
             raise ChefFS::FileSystem::NotFoundError.new(self, @could_not_get_chef_object)
           else
-            raise
+            raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
           end
         end
       end

data/lib/chef_fs/file_system/cookbook_file.rb

@@ -38,6 +38,8 @@ module ChefFS
         rest.sign_on_redirect = false
         begin
           tmpfile = rest.get_rest(file[:url], true)
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "Timeout reading #{file[:url]}: #{e}"
         rescue Net::HTTPServerException => e
           raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "#{e.message} retrieving #{file[:url]}"
         ensure

data/lib/chef_fs/file_system/cookbooks_dir.rb

@@ -64,6 +64,8 @@ module ChefFS
 
       def upload_cookbook_from(other)
         Chef::Config[:versioned_cookbooks] ? upload_versioned_cookbook(other) : upload_unversioned_cookbook(other)
+      rescue Timeout::Error => e
+        raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Timeout writing: #{e}"
       rescue Net::HTTPServerException => e
         case e.response.code
         when "409"
@@ -71,7 +73,7 @@ module ChefFS
           Chef::Log.debug(e)
           raise Exceptions::CookbookFrozen
         else
-          raise
+          raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "HTTP error writing: #{e}"
         end
       end
 

data/lib/chef_fs/file_system/data_bag_dir.rb

@@ -52,9 +52,13 @@ module ChefFS
         end
         begin
           rest.delete_rest(api_path)
-        rescue Net::HTTPServerException
-          if $!.response.code == "404"
-            raise ChefFS::FileSystem::NotFoundError.new(self, $!)
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "Timeout deleting: #{e}"
+        rescue Net::HTTPServerException => e
+          if e.response.code == "404"
+            raise ChefFS::FileSystem::NotFoundError.new(self, e)
+          else
+            raise ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "HTTP error deleting: #{e}"
           end
         end
       end

data/lib/chef_fs/file_system/data_bags_dir.rb

@@ -36,11 +36,13 @@ module ChefFS
           @children ||= ChefFS::RawRequest.raw_json(rest, api_path).keys.sort.map do |entry|
             DataBagDir.new(entry, self, true)
           end
-        rescue Net::HTTPServerException
-          if $!.response.code == "404"
-            raise ChefFS::FileSystem::NotFoundError.new(self, $!)
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:children, self, e), "Timeout getting children: #{e}"
+        rescue Net::HTTPServerException => e
+          if e.response.code == "404"
+            raise ChefFS::FileSystem::NotFoundError.new(self, e)
           else
-            raise
+            raise ChefFS::FileSystem::OperationFailedError.new(:children, self, e), "HTTP error getting children: #{e}"
           end
         end
       end
@@ -52,9 +54,11 @@ module ChefFS
       def create_child(name, file_contents)
         begin
           rest.post_rest(api_path, { 'name' => name })
-        rescue Net::HTTPServerException
-          if $!.response.code != "409"
-            raise
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:create_child, self, e), "Timeout creating child '#{name}': #{e}"
+        rescue Net::HTTPServerException => e
+          if e.response.code != "409"
+            raise ChefFS::FileSystem::OperationFailedError.new(:create_child, self, e), "HTTP error creating child '#{name}': #{e}"
           end
         end
         DataBagDir.new(name, self, true)

data/lib/chef_fs/file_system/memory_dir.rb

@@ -0,0 +1,50 @@
+require 'chef_fs/file_system/base_fs_dir'
+require 'chef_fs/file_system/nonexistent_fs_object'
+require 'chef_fs/file_system/memory_file'
+
+module ChefFS
+  module FileSystem
+    class MemoryDir < ChefFS::FileSystem::BaseFSDir
+      def initialize(name, parent)
+        super(name, parent)
+        @children = []
+      end
+
+      attr_reader :children
+
+      def child(name)
+        @children.select { |child| child.name == name }.first || ChefFS::FileSystem::NonexistentFSObject.new(name, self)
+      end
+
+      def add_child(child)
+        @children.push(child)
+      end
+
+      def can_have_child?(name, is_dir)
+        root.cannot_be_in_regex ? (name !~ root.cannot_be_in_regex) : true
+      end
+
+      def add_file(path, value)
+        path_parts = path.split('/')
+        dir = add_dir(path_parts[0..-2].join('/'))
+        file = MemoryFile.new(path_parts[-1], dir, value)
+        dir.add_child(file)
+        file
+      end
+
+      def add_dir(path)
+        path_parts = path.split('/')
+        dir = self
+        path_parts.each do |path_part|
+          subdir = dir.child(path_part)
+          if !subdir.exists?
+            subdir = MemoryDir.new(path_part, dir)
+            dir.add_child(subdir)
+          end
+          dir = subdir
+        end
+        dir
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/memory_file.rb

@@ -0,0 +1,15 @@
+require 'chef_fs/file_system/base_fs_object'
+
+module ChefFS
+  module FileSystem
+    class MemoryFile < ChefFS::FileSystem::BaseFSObject
+      def initialize(name, parent, value)
+        super(name, parent)
+        @value = value
+      end
+      def read
+        return @value
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/memory_root.rb

@@ -0,0 +1,19 @@
+require 'chef_fs/file_system/memory_dir'
+
+module ChefFS
+  module FileSystem
+    class MemoryRoot < MemoryDir
+      def initialize(pretty_name, cannot_be_in_regex = nil)
+        super('', nil)
+        @pretty_name = pretty_name
+        @cannot_be_in_regex = cannot_be_in_regex
+      end
+
+      attr_reader :cannot_be_in_regex
+
+      def path_for_printing
+        @pretty_name
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/nodes_dir.rb

@@ -34,6 +34,8 @@ module ChefFS
           @children ||= ChefFS::RawRequest.raw_json(rest, env_api_path).keys.sort.map do |key|
             _make_child_entry("#{key}.json", true)
           end
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:children, self, e), "Timeout retrieving children: #{e}"
         rescue Net::HTTPServerException => e
           if $!.response.code == "404"
             raise ChefFS::FileSystem::NotFoundError.new(self, $!)

data/lib/chef_fs/file_system/rest_list_dir.rb

@@ -47,6 +47,8 @@ module ChefFS
           @children ||= ChefFS::RawRequest.raw_json(rest, api_path).keys.sort.map do |key|
             _make_child_entry("#{key}.json", true)
           end
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:children, self, e), "Timeout retrieving children: #{e}"
         rescue Net::HTTPServerException => e
           if $!.response.code == "404"
             raise ChefFS::FileSystem::NotFoundError.new(self, $!)
@@ -74,6 +76,8 @@ module ChefFS
 
         begin
           rest.post_rest(api_path, object)
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:create_child, self, e), "Timeout creating '#{name}': #{e}"
         rescue Net::HTTPServerException => e
           if e.response.code == "404"
             raise ChefFS::FileSystem::NotFoundError.new(self, e)

data/lib/chef_fs/file_system/rest_list_entry.rb

@@ -68,11 +68,13 @@ module ChefFS
       def delete(recurse)
         begin
           rest.delete_rest(api_path)
-        rescue Net::HTTPServerException
-          if $!.response.code == "404"
-            raise ChefFS::FileSystem::NotFoundError.new(self, $!)
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "Timeout deleting: #{e}"
+        rescue Net::HTTPServerException => e
+          if e.response.code == "404"
+            raise ChefFS::FileSystem::NotFoundError.new(self, e)
           else
-            raise
+            raise ChefFS::FileSystem::OperationFailedError.new(:delete, self, e), "Timeout deleting: #{e}"
           end
         end
       end
@@ -84,9 +86,11 @@ module ChefFS
       def _read_hash
         begin
           json = ChefFS::RawRequest.raw_request(rest, api_path)
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "Timeout reading: #{e}"
         rescue Net::HTTPServerException => e
           if $!.response.code == "404"
-            raise ChefFS::FileSystem::NotFoundError.new(self, $!)
+            raise ChefFS::FileSystem::NotFoundError.new(self, e)
           else
             raise ChefFS::FileSystem::OperationFailedError.new(:read, self, e), "HTTP error reading: #{e}"
           end
@@ -125,7 +129,6 @@ module ChefFS
         value = minimize_value(value)
         value_json = Chef::JSONCompat.to_json_pretty(value)
         begin
-          #other_value = Chef::JSONCompat.from_json(other_value_json, :create_additions => false)
           other_value = JSON.parse(other_value_json, :create_additions => false)
         rescue JSON::ParserError => e
           Chef::Log.warn("Parse error reading #{other.path_for_printing} as JSON: #{e}")
@@ -143,7 +146,6 @@ module ChefFS
 
       def write(file_contents)
         begin
-          #object = Chef::JSONCompat.from_json(file_contents).to_hash
           object = JSON.parse(file_contents, :create_additions => false)
         rescue JSON::ParserError => e
           raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Parse error reading JSON: #{e}"
@@ -158,6 +160,8 @@ module ChefFS
 
         begin
           rest.put_rest(api_path, object)
+        rescue Timeout::Error => e
+          raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Timeout writing: #{e}"
         rescue Net::HTTPServerException => e
           if e.response.code == "404"
             raise ChefFS::FileSystem::NotFoundError.new(self, e)

data/lib/chef_fs/knife.rb

@@ -96,7 +96,11 @@ module ChefFS
     end
 
     def chef_fs
-      @chef_fs ||= ChefFS::FileSystem::ChefServerRootDir.new("remote", Chef::Config)
+      @chef_fs ||= create_chef_fs
+    end
+
+    def create_chef_fs
+      ChefFS::FileSystem::ChefServerRootDir.new("remote", Chef::Config)
     end
 
     def object_paths
@@ -193,7 +197,11 @@ module ChefFS
     end
 
     def local_fs
-      @local_fs ||= ChefFS::FileSystem::ChefRepositoryFileSystemRootDir.new(object_paths)
+      @local_fs ||= create_local_fs
+    end
+
+    def create_local_fs
+      ChefFS::FileSystem::ChefRepositoryFileSystemRootDir.new(object_paths)
     end
 
     def pattern_args

data/lib/chef_fs/version.rb

@@ -1,3 +1,3 @@
 module ChefFS
-  VERSION = "1.0.0"
+  VERSION = "1.1"
 end

data/spec/support/file_system_support.rb

@@ -17,56 +17,16 @@
 #
 
 require 'chef_fs/file_system'
-require 'chef_fs/file_system/base_fs_dir'
-require 'chef_fs/file_system/base_fs_object'
+require 'chef_fs/file_system/memory_root'
+require 'chef_fs/file_system/memory_dir'
+require 'chef_fs/file_system/memory_file'
 
 module FileSystemSupport
-  class MemoryFile < ChefFS::FileSystem::BaseFSObject
-    def initialize(name, parent, value)
-      super(name, parent)
-      @value = value
-    end
-    def read
-      return @value
-    end
-  end
-
-  class MemoryDir < ChefFS::FileSystem::BaseFSDir
-    def initialize(name, parent)
-      super(name, parent)
-      @children = []
-    end
-    attr_reader :children
-    def child(name)
-      @children.select { |child| child.name == name }.first || ChefFS::FileSystem::NonexistentFSObject.new(name, self)
-    end
-    def add_child(child)
-      @children.push(child)
-    end
-    def can_have_child?(name, is_dir)
-      root.cannot_be_in_regex ? (name !~ root.cannot_be_in_regex) : true
-    end
-  end
-
-  class MemoryRoot < MemoryDir
-    def initialize(pretty_name, cannot_be_in_regex = nil)
-      super('', nil)
-      @pretty_name = pretty_name
-      @cannot_be_in_regex = cannot_be_in_regex
-    end
-
-    attr_reader :cannot_be_in_regex
-
-    def path_for_printing
-      @pretty_name
-    end
-  end
-
   def memory_fs(pretty_name, value, cannot_be_in_regex = nil)
     if !value.is_a?(Hash)
       raise "memory_fs() must take a Hash"
     end
-    dir = MemoryRoot.new(pretty_name, cannot_be_in_regex)
+    dir = ChefFS::FileSystem::MemoryRoot.new(pretty_name, cannot_be_in_regex)
     value.each do |key, child|
       dir.add_child(memory_fs_value(child, key.to_s, dir))
     end
@@ -75,13 +35,13 @@ module FileSystemSupport
 
   def memory_fs_value(value, name = '', parent = nil)
     if value.is_a?(Hash)
-      dir = MemoryDir.new(name, parent)
+      dir = ChefFS::FileSystem::MemoryDir.new(name, parent)
       value.each do |key, child|
         dir.add_child(memory_fs_value(child, key.to_s, dir))
       end
       dir
     else
-      MemoryFile.new(name, parent, value || "#{name}\n")
+      ChefFS::FileSystem::MemoryFile.new(name, parent, value || "#{name}\n")
     end
   end
 
@@ -94,7 +54,7 @@ module FileSystemSupport
   end
 
   def no_blocking_calls_allowed
-    [ MemoryFile, MemoryDir ].each do |c|
+    [ ChefFS::FileSystem::MemoryFile, ChefFS::FileSystem::MemoryDir ].each do |c|
       [ :children, :exists?, :read ].each do |m|
         c.any_instance.stub(m).and_raise("#{m.to_s} should not be called")
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-essentials
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: '1.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-20 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -125,6 +125,7 @@ files:
 - lib/chef/knife/edit_essentials.rb
 - lib/chef/knife/list_essentials.rb
 - lib/chef/knife/raw_essentials.rb
+- lib/chef/knife/serve_essentials.rb
 - lib/chef/knife/show_essentials.rb
 - lib/chef/knife/upload_essentials.rb
 - lib/chef/knife/xargs_essentials.rb
@@ -163,6 +164,9 @@ files:
 - lib/chef_fs/file_system/file_system_entry.rb
 - lib/chef_fs/file_system/file_system_error.rb
 - lib/chef_fs/file_system/file_system_root_dir.rb
+- lib/chef_fs/file_system/memory_dir.rb
+- lib/chef_fs/file_system/memory_file.rb
+- lib/chef_fs/file_system/memory_root.rb
 - lib/chef_fs/file_system/multiplexed_dir.rb
 - lib/chef_fs/file_system/must_delete_recursively_error.rb
 - lib/chef_fs/file_system/nodes_dir.rb