knife-essentials 1.2 → 1.2.1

data/lib/chef/knife/raw_essentials.rb

@@ -4,12 +4,12 @@ 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"
 
       deps do
         require 'json'
-        require 'chef_fs/data_handler/data_handler_base'
+        require 'chef/rest'
+        require 'chef/config'
         require 'chef_fs/raw_request'
       end
 
@@ -48,7 +48,7 @@ class Chef
         end
         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)
+          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

data/lib/chef/knife/serve_essentials.rb

@@ -19,13 +19,7 @@ ERROR: chef-zero must be installed to run "knife serve"!  To install:
 EOM
           exit(1)
         end
-        require 'chef_zero/data_store/memory_store'
-        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'
+        require 'chef_fs/chef_fs_data_store'
       end
 
       option :remote,
@@ -50,7 +44,7 @@ EOM
 
       def run
         server_options = {}
-        server_options[:data_store] = ChefFSDataStore.new(proc { config[:remote] ? create_chef_fs : create_local_fs })
+        server_options[:data_store] = ChefFS::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
@@ -58,349 +52,6 @@ EOM
 
         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/chef_fs_data_store.rb

@@ -0,0 +1,373 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef_zero/data_store/memory_store'
+require 'chef_zero/data_store/data_already_exists_error'
+require 'chef_zero/data_store/data_not_found_error'
+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'
+
+module ChefFS
+  class ChefFSDataStore
+    def initialize(chef_fs)
+      @chef_fs = chef_fs
+      @memory_store = ChefZero::DataStore::MemoryStore.new
+    end
+
+    def publish_description
+      "Reading and writing data to #{chef_fs.fs_description}"
+    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
+      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

data/lib/chef_fs/config.rb

@@ -0,0 +1,193 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/log'
+require 'chef_fs/path_utils'
+
+module ChefFS
+  #
+  # Helpers to take Chef::Config and create chef_fs and local_fs from it
+  #
+  class Config
+    def initialize(chef_config = Chef::Config, cwd = Dir.pwd)
+      @chef_config = chef_config
+      @cwd = cwd
+      configure_repo_paths
+    end
+
+    PATH_VARIABLES = %w(acl_path client_path cookbook_path container_path data_bag_path environment_path group_path node_path role_path user_path)
+
+    def chef_fs
+      @chef_fs ||= create_chef_fs
+    end
+
+    def create_chef_fs
+      require 'chef_fs/file_system/chef_server_root_dir'
+      ChefFS::FileSystem::ChefServerRootDir.new("remote", @chef_config)
+    end
+
+    def local_fs
+      @local_fs ||= create_local_fs
+    end
+
+    def create_local_fs
+      require 'chef_fs/file_system/chef_repository_file_system_root_dir'
+      ChefFS::FileSystem::ChefRepositoryFileSystemRootDir.new(object_paths)
+    end
+
+    # Returns the given real path's location relative to the server root.
+    #
+    # If chef_repo is /home/jkeiser/chef_repo,
+    # and pwd is /home/jkeiser/chef_repo/cookbooks,
+    # server_path('blah') == '/cookbooks/blah'
+    # server_path('../roles/blah.json') == '/roles/blah'
+    # server_path('../../readme.txt') == nil
+    # server_path('*/*ab*') == '/cookbooks/*/*ab*'
+    # server_path('/home/jkeiser/chef_repo/cookbooks/blah') == '/cookbooks/blah'
+    # server_path('/home/*/chef_repo/cookbooks/blah') == nil
+    #
+    # If there are multiple paths (cookbooks, roles, data bags, etc. can all
+    # have separate paths), and cwd+the path reaches into one of them, we will
+    # return a path relative to that.  Otherwise we will return a path to
+    # chef_repo.
+    #
+    # Globs are allowed as well, but globs outside server paths are NOT
+    # (presently) supported.  See above examples.  TODO support that.
+    #
+    # If the path does not reach into ANY specified directory, nil is returned.
+    def server_path(file_path)
+      pwd = File.expand_path(Dir.pwd)
+      absolute_path = ChefFS::PathUtils.realest_path(File.expand_path(file_path, pwd))
+
+      # Check all object paths (cookbooks_dir, data_bags_dir, etc.)
+      object_paths.each_pair do |name, paths|
+        paths.each do |path|
+          realest_path = ChefFS::PathUtils.realest_path(path)
+          if absolute_path[0,realest_path.length] == realest_path &&
+            (absolute_path.length == realest_path.length ||
+              absolute_path[realest_path.length,1] =~ /#{PathUtils.regexp_path_separator}/)
+            relative_path = ChefFS::PathUtils::relative_to(absolute_path, realest_path)
+            return relative_path == '.' ? "/#{name}" : "/#{name}/#{relative_path}"
+          end
+        end
+      end
+
+      # Check 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 '/'
+        end
+      end
+
+      nil
+    end
+
+    # The current directory, relative to server root
+    def base_path
+      @base_path ||= server_path(File.expand_path(@cwd))
+    end
+
+    # Print the given server path, relative to the current directory
+    def format_path(entry)
+      server_path = entry.path
+      if base_path && server_path[0,base_path.length] == base_path
+        if server_path == base_path
+          return "."
+        elsif server_path[base_path.length,1] == "/"
+          return server_path[base_path.length + 1, server_path.length - base_path.length - 1]
+        elsif base_path == "/" && server_path[0,1] == "/"
+          return server_path[1, server_path.length - 1]
+        end
+      end
+      server_path
+    end
+
+    private
+
+    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 = {}
+        case @chef_config[:repo_mode]
+        when 'static'
+          object_names = %w(cookbooks data_bags environments roles)
+        when 'hosted_everything'
+          object_names = %w(acls clients cookbooks containers data_bags environments groups nodes roles)
+        else
+          object_names = %w(clients cookbooks data_bags environments nodes roles users)
+        end
+        object_names.each do |object_name|
+          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
+    end
+
+    def configure_repo_paths
+      # Smooth out some (for now) inappropriate defaults set by Chef
+      if @chef_config[:cookbook_path] == [ @chef_config.platform_specific_path("/var/chef/cookbooks"),
+                    @chef_config.platform_specific_path("/var/chef/site-cookbooks") ]
+        @chef_config[:cookbook_path] = nil
+      end
+      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 @chef_config[:role_path] == @chef_config.platform_specific_path('/var/chef/roles')
+        @chef_config[:role_path] = nil
+      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
+
+      # Default to getting *everything* from the server.
+      if !@chef_config[:repo_mode]
+        if @chef_config[:chef_server_url] =~ /\/+organizations\/.+/
+          @chef_config[:repo_mode] = 'hosted_everything'
+        else
+          @chef_config[:repo_mode] = 'everything'
+        end
+      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
+  end
+end

data/lib/chef_fs/file_system/chef_repository_file_system_root_dir.rb

@@ -67,6 +67,23 @@ module ChefFS
         nil
       end
 
+      # Used to print out the filesystem
+      def fs_description
+        repo_path = File.dirname(child_paths['cookbooks'][0])
+        result = "repository at #{repo_path}\n"
+        if Chef::Config[:versioned_cookbooks]
+          result << "  Multiple versions per cookbook\n"
+        else
+          result << "  One version per cookbook\n"
+        end
+        child_paths.each_pair do |name, paths|
+          if paths.any? { |path| File.dirname(path) != repo_path }
+            result << "  #{name} at #{paths.join(', ')}\n"
+          end
+        end
+        result
+      end
+
       private
 
       def make_child_entry(name)

data/lib/chef_fs/file_system/chef_server_root_dir.rb

@@ -49,6 +49,10 @@ module ChefFS
       attr_reader :environment
       attr_reader :repo_mode
 
+      def fs_description
+        "Chef server at #{chef_server_url} (user #{chef_username}), repo_mode = #{repo_mode}"
+      end
+
       def rest
         Chef::REST.new(chef_server_url, chef_username, chef_private_key)
       end

data/lib/chef_fs/file_system/cookbooks_dir.rb

@@ -75,6 +75,8 @@ module ChefFS
         else
           raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "HTTP error writing: #{e}"
         end
+      rescue Chef::Exceptions::CookbookFrozen => e
+        raise ChefFS::FileSystem::CookbookFrozenError.new(:write, self, e), "Cookbook #{other.name} is frozen"
       end
 
       # Knife currently does not understand versioned cookbooks

data/lib/chef_fs/knife.rb

@@ -23,14 +23,20 @@ module ChefFS
     # Workaround for CHEF-3932
     def self.deps
       super do
-        require 'chef_fs/file_system/chef_server_root_dir'
-        require 'chef_fs/file_system/chef_repository_file_system_root_dir'
+        require 'chef/config'
+        require 'chef_fs/parallelizer'
+        require 'chef_fs/config'
         require 'chef_fs/file_pattern'
         require 'chef_fs/path_utils'
-        require 'chef_fs/parallelizer'
-        require 'chef/config'
         yield
       end
+    end
+
+    def self.inherited(c)
+      super
+      # Ensure we always get to do our includes, whether subclass calls deps or not
+      c.deps do
+      end
 
       option :repo_mode,
         :long => '--repo-mode MODE',
@@ -45,176 +51,38 @@ module ChefFS
         :description => 'Maximum number of simultaneous requests to send (default: 10)'
     end
 
-    def self.inherited(c)
-      super
-      # Ensure we always get to do our includes, whether subclass calls deps or not
-      c.deps do
-      end
-    end
-
     def configure_chef
       super
       Chef::Config[:repo_mode] = config[:repo_mode] if config[:repo_mode]
       Chef::Config[:concurrency] = config[:concurrency].to_i if config[:concurrency]
 
       # --chef-repo-path overrides all other paths
-      path_variables = %w(acl_path client_path cookbook_path container_path data_bag_path environment_path group_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
-
-      # 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 Chef::Config[:role_path] == Chef::Config.platform_specific_path('/var/chef/roles')
-        Chef::Config[:role_path] = nil
-      end
-
-      # Default to getting *everything* from the server.
-      if !Chef::Config[:repo_mode]
-        if Chef::Config[:chef_server_url] =~ /\/+organizations\/.+/
-          Chef::Config[:repo_mode] = 'hosted_everything'
-        else
-          Chef::Config[:repo_mode] = 'everything'
+        ChefFS::Config::PATH_VARIABLES.each do |variable_name|
+          Chef::Config[variable_name.to_sym] = chef_repo_paths.map { |path| File.join(path, "#{variable_name[0..-6]}s") }
         end
       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
+      @chef_fs_config = ChefFS::Config.new(Chef::Config)
 
       ChefFS::Parallelizer.threads = (Chef::Config[:concurrency] || 10) - 1
     end
 
     def chef_fs
-      @chef_fs ||= create_chef_fs
+      @chef_fs_config.chef_fs
     end
 
     def create_chef_fs
-      ChefFS::FileSystem::ChefServerRootDir.new("remote", Chef::Config)
-    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 = {}
-        case Chef::Config[:repo_mode]
-        when 'static'
-          object_names = %w(cookbooks data_bags environments roles)
-        when 'hosted_everything'
-          object_names = %w(acls clients cookbooks containers data_bags environments groups nodes roles)
-        else
-          object_names = %w(clients cookbooks data_bags environments nodes roles users)
-        end
-        object_names.each do |object_name|
-          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
-    end
-
-    # Returns the given real path's location relative to the server root.
-    #
-    # If chef_repo is /home/jkeiser/chef_repo,
-    # and pwd is /home/jkeiser/chef_repo/cookbooks,
-    # server_path('blah') == '/cookbooks/blah'
-    # server_path('../roles/blah.json') == '/roles/blah'
-    # server_path('../../readme.txt') == nil
-    # server_path('*/*ab*') == '/cookbooks/*/*ab*'
-    # server_path('/home/jkeiser/chef_repo/cookbooks/blah') == '/cookbooks/blah'
-    # server_path('/home/*/chef_repo/cookbooks/blah') == nil
-    #
-    # If there are multiple paths (cookbooks, roles, data bags, etc. can all
-    # have separate paths), and cwd+the path reaches into one of them, we will
-    # return a path relative to that.  Otherwise we will return a path to
-    # chef_repo.
-    #
-    # Globs are allowed as well, but globs outside server paths are NOT
-    # (presently) supported.  See above examples.  TODO support that.
-    #
-    # If the path does not reach into ANY specified directory, nil is returned.
-    def server_path(file_path)
-      pwd = File.expand_path(Dir.pwd)
-      absolute_path = ChefFS::PathUtils.realest_path(File.expand_path(file_path, pwd))
-
-      # Check all object paths (cookbooks_dir, data_bags_dir, etc.)
-      object_paths.each_pair do |name, paths|
-        paths.each do |path|
-          realest_path = ChefFS::PathUtils.realest_path(path)
-          if absolute_path[0,realest_path.length] == realest_path &&
-            (absolute_path.length == realest_path.length ||
-              absolute_path[realest_path.length,1] =~ /#{PathUtils.regexp_path_separator}/)
-            relative_path = ChefFS::PathUtils::relative_to(absolute_path, realest_path)
-            return relative_path == '.' ? "/#{name}" : "/#{name}/#{relative_path}"
-          end
-        end
-      end
-
-      # Check 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 '/'
-        end
-      end
-
-      nil
-    end
-
-    # The current directory, relative to server root
-    def base_path
-      @base_path ||= server_path(File.expand_path(Dir.pwd))
-    end
-
-    # Print the given server path, relative to the current directory
-    def format_path(entry)
-      server_path = entry.path
-      if base_path && server_path[0,base_path.length] == base_path
-        if server_path == base_path
-          return "."
-        elsif server_path[base_path.length,1] == "/"
-          return server_path[base_path.length + 1, server_path.length - base_path.length - 1]
-        elsif base_path == "/" && server_path[0,1] == "/"
-          return server_path[1, server_path.length - 1]
-        end
-      end
-      server_path
+      @chef_fs_config.create_chef_fs
     end
 
     def local_fs
-      @local_fs ||= create_local_fs
+      @chef_fs_config.local_fs
     end
 
     def create_local_fs
-      ChefFS::FileSystem::ChefRepositoryFileSystemRootDir.new(object_paths)
+      @chef_fs_config.create_local_fs
     end
 
     def pattern_args
@@ -225,14 +93,18 @@ module ChefFS
       # TODO support absolute file paths and not just patterns?  Too much?
       # Could be super useful in a world with multiple repo paths
       args.map do |arg|
-        if !base_path && !PathUtils.is_absolute?(arg)
+        if !@chef_fs_config.base_path && !ChefFS::PathUtils.is_absolute?(arg)
           ui.error("Attempt to use relative path '#{arg}' when current directory is outside the repository path")
           exit(1)
         end
-        ChefFS::FilePattern::relative_to(base_path, arg)
+        ChefFS::FilePattern.relative_to(@chef_fs_config.base_path, arg)
       end
     end
 
+    def format_path(entry)
+      @chef_fs_config.format_path(entry)
+    end
+
     def parallelize(inputs, options = {}, &block)
       ChefFS::Parallelizer.parallelize(inputs, options, &block)
     end

data/lib/chef_fs/version.rb

@@ -1,3 +1,3 @@
 module ChefFS
-  VERSION = "1.2"
+  VERSION = "1.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-essentials
 version: !ruby/object:Gem::Version
-  version: '1.2'
+  version: 1.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-03 00:00:00.000000000 Z
+date: 2013-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -129,7 +129,9 @@ files:
 - lib/chef/knife/show_essentials.rb
 - lib/chef/knife/upload_essentials.rb
 - lib/chef/knife/xargs_essentials.rb
+- lib/chef_fs/chef_fs_data_store.rb
 - lib/chef_fs/command_line.rb
+- lib/chef_fs/config.rb
 - lib/chef_fs/data_handler/acl_data_handler.rb
 - lib/chef_fs/data_handler/client_data_handler.rb
 - lib/chef_fs/data_handler/container_data_handler.rb