knife-essentials 0.9.4 → 0.9.5

data/lib/chef/knife/diff_essentials.rb

@@ -44,13 +44,10 @@ class Chef
         error = false
         begin
           patterns.each do |pattern|
-            found_match = ChefFS::CommandLine.diff_print(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode, proc { |entry| format_path(entry) }, config[:diff_filter] ) do |diff|
+            found_error = ChefFS::CommandLine.diff_print(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode, proc { |entry| format_path(entry) }, config[:diff_filter], ui ) do |diff|
               stdout.print diff
             end
-            if !found_match
-              ui.error "#{pattern}: No such file or directory on remote or local"
-              error = true
-            end
+            error = true if found_error
           end
         rescue ChefFS::FileSystem::OperationFailedError => e
           ui.error "Failed on #{format_path(e.entry)} in #{e.operation}: #{e.message}"

data/lib/chef/knife/raw_essentials.rb

@@ -1,6 +1,6 @@
 require 'json'
 require 'chef_fs/data_handler/data_handler_base'
-require 'chef_fs/file_system/base_fs_object'
+require 'chef_fs/raw_request'
 
 class Chef
   class Knife
@@ -44,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::RawRequest.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/command_line.rb

@@ -17,18 +17,20 @@
 #
 
 require 'chef_fs/file_system'
+require 'chef_fs/file_system/operation_failed_error'
+require 'chef_fs/file_system/operation_not_allowed_error'
 
 module ChefFS
   module CommandLine
 
-    def self.diff_print(pattern, a_root, b_root, recurse_depth, output_mode, format_path = nil, diff_filter = nil)
+    def self.diff_print(pattern, a_root, b_root, recurse_depth, output_mode, format_path = nil, diff_filter = nil, ui = nil)
       if format_path.nil?
         format_path = proc { |entry| entry.path_for_printing }
       end
 
       get_content = (output_mode != :name_only && output_mode != :name_status)
       found_match = false
-      diff(pattern, a_root, b_root, recurse_depth, get_content) do |type, old_entry, new_entry, old_value, new_value|
+      diff(pattern, a_root, b_root, recurse_depth, get_content) do |type, old_entry, new_entry, old_value, new_value, error|
         found_match = true unless type == :both_nonexistent
         old_path = format_path.call(old_entry)
         new_path = format_path.call(new_entry)
@@ -104,9 +106,22 @@ module ChefFS
         when :deleted_cannot_download
         when :same
           # Skip these silently
+        when :error
+          if error.is_a?(ChefFS::FileSystem::OperationFailedError)
+            ui.error "#{format_path.call(error.entry)} failed to #{error.operation}: #{error.message}" if ui
+            error = true
+          elsif error.is_a?(ChefFS::FileSystem::OperationNotAllowedError)
+            ui.error "#{format_path.call(error.entry)} #{error.reason}." if ui
+          else
+            raise error
+          end
         end
       end
-      found_match
+      if !found_match
+        ui.error "#{pattern}: No such file or directory on remote or local" if ui
+        error = true
+      end
+      error
     end
 
     def self.diff(pattern, a_root, b_root, recurse_depth, get_content)
@@ -119,98 +134,102 @@ module ChefFS
 
     # Diff two known entries (could be files or dirs)
     def self.diff_entries(old_entry, new_entry, recurse_depth, get_content)
-      # If both are directories
-      if old_entry.dir?
-        if new_entry.dir?
-          if recurse_depth == 0
-            yield [ :common_subdirectories, old_entry, new_entry ]
-          else
-            ChefFS::FileSystem.child_pairs(old_entry, new_entry).each do |old_child,new_child|
-              diff_entries(old_child, new_child,
-                           recurse_depth ? recurse_depth - 1 : nil, get_content) do |diff|
-                yield diff
+      begin
+        # If both are directories
+        if old_entry.dir?
+          if new_entry.dir?
+            if recurse_depth == 0
+              yield [ :common_subdirectories, old_entry, new_entry ]
+            else
+              ChefFS::FileSystem.child_pairs(old_entry, new_entry).each do |old_child,new_child|
+                diff_entries(old_child, new_child,
+                             recurse_depth ? recurse_depth - 1 : nil, get_content) do |diff|
+                  yield diff
+                end
               end
             end
-          end
 
-      # If old is a directory and new is a file
-        elsif new_entry.exists?
-          yield [ :directory_to_file, old_entry, new_entry ]
-
-      # If old is a directory and new does not exist
-        elsif new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
-          yield [ :deleted, old_entry, new_entry ]
-        end
+        # If old is a directory and new is a file
+          elsif new_entry.exists?
+            yield [ :directory_to_file, old_entry, new_entry ]
 
-      # If new is a directory and old is a file
-      elsif new_entry.dir?
-        if old_entry.exists?
-          yield [ :file_to_directory, old_entry, new_entry ]
+        # If old is a directory and new does not exist
+          elsif new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
+            yield [ :deleted, old_entry, new_entry ]
+          end
 
-      # If new is a directory and old does not exist
-        elsif old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
-          yield [ :added, old_entry, new_entry ]
-        end
+        # If new is a directory and old is a file
+        elsif new_entry.dir?
+          if old_entry.exists?
+            yield [ :file_to_directory, old_entry, new_entry ]
 
-      # Neither is a directory, so they are diffable with file diff
-      else
-        are_same, old_value, new_value = ChefFS::FileSystem.compare(old_entry, new_entry)
-        if are_same
-          if old_value == :none
-            yield [ :both_nonexistent, old_entry, new_entry ]
-          else
-            yield [ :same, old_entry, new_entry ]
-          end
-        else
-          if old_value == :none
-            old_exists = false
-          elsif old_value.nil?
-            old_exists = old_entry.exists?
-          else
-            old_exists = true
+        # If new is a directory and old does not exist
+          elsif old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
+            yield [ :added, old_entry, new_entry ]
           end
 
-          if new_value == :none
-            new_exists = false
-          elsif new_value.nil?
-            new_exists = new_entry.exists?
+        # Neither is a directory, so they are diffable with file diff
+        else
+          are_same, old_value, new_value = ChefFS::FileSystem.compare(old_entry, new_entry)
+          if are_same
+            if old_value == :none
+              yield [ :both_nonexistent, old_entry, new_entry ]
+            else
+              yield [ :same, old_entry, new_entry ]
+            end
           else
-            new_exists = true
-          end
+            if old_value == :none
+              old_exists = false
+            elsif old_value.nil?
+              old_exists = old_entry.exists?
+            else
+              old_exists = true
+            end
 
-          # If one of the files doesn't exist, we only want to print the diff if the
-          # other file *could be uploaded/downloaded*.
-          if !old_exists && !old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
-            yield [ :old_cannot_upload, old_entry, new_entry ]
-            return
-          end
-          if !new_exists && !new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
-            yield [ :new_cannot_upload, old_entry, new_entry ]
-            return
-          end
+            if new_value == :none
+              new_exists = false
+            elsif new_value.nil?
+              new_exists = new_entry.exists?
+            else
+              new_exists = true
+            end
 
-          if get_content
-            # If we haven't read the values yet, get them now so that they can be diffed
-            begin
-              old_value = old_entry.read if old_value.nil?
-            rescue ChefFS::FileSystem::NotFoundError
-              old_value = :none
+            # If one of the files doesn't exist, we only want to print the diff if the
+            # other file *could be uploaded/downloaded*.
+            if !old_exists && !old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
+              yield [ :old_cannot_upload, old_entry, new_entry ]
+              return
             end
-            begin
-              new_value = new_entry.read if new_value.nil?
-            rescue ChefFS::FileSystem::NotFoundError
-              new_value = :none
+            if !new_exists && !new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
+              yield [ :new_cannot_upload, old_entry, new_entry ]
+              return
             end
-          end
 
-          if old_value == :none || (old_value == nil && !old_entry.exists?)
-            yield [ :added, old_entry, new_entry, old_value, new_value ]
-          elsif new_value == :none
-            yield [ :deleted, old_entry, new_entry, old_value, new_value ]
-          else
-            yield [ :modified, old_entry, new_entry, old_value, new_value ]
+            if get_content
+              # If we haven't read the values yet, get them now so that they can be diffed
+              begin
+                old_value = old_entry.read if old_value.nil?
+              rescue ChefFS::FileSystem::NotFoundError
+                old_value = :none
+              end
+              begin
+                new_value = new_entry.read if new_value.nil?
+              rescue ChefFS::FileSystem::NotFoundError
+                new_value = :none
+              end
+            end
+
+            if old_value == :none || (old_value == nil && !old_entry.exists?)
+              yield [ :added, old_entry, new_entry, old_value, new_value ]
+            elsif new_value == :none
+              yield [ :deleted, old_entry, new_entry, old_value, new_value ]
+            else
+              yield [ :modified, old_entry, new_entry, old_value, new_value ]
+            end
           end
         end
+      rescue ChefFS::FileSystem::FileSystemError => e
+        yield [ :error, old_entry, new_entry, nil, nil, e ]
       end
     end
 

data/lib/chef_fs/data_handler/acl_data_handler.rb

@@ -0,0 +1,22 @@
+require 'chef_fs/data_handler/data_handler_base'
+
+module ChefFS
+  module DataHandler
+    class AclDataHandler < DataHandlerBase
+      def normalize(node, entry)
+        # Normalize the order of the keys for easier reading
+        result = super(node, {
+          'create' => {},
+          'read' => {},
+          'update' => {},
+          'delete' => {},
+          'grant' => {}
+          })
+        result.keys.each do |key|
+          result[key] = super(result[key], { 'actors' => [], 'groups' => [] })
+        end
+        result
+      end
+    end
+  end
+end

data/lib/chef_fs/data_handler/container_data_handler.rb

@@ -0,0 +1,20 @@
+require 'chef_fs/data_handler/data_handler_base'
+
+module ChefFS
+  module DataHandler
+    class ContainerDataHandler < DataHandlerBase
+      def normalize(user, entry)
+        super(user, {
+          'containername' => remove_dot_json(entry.name),
+          'containerpath' => remove_dot_json(entry.name)
+        })
+      end
+
+      def preserve_key(key)
+        return key == 'containername'
+      end
+
+      # There is no chef_class for users, nor does to_ruby work.
+    end
+  end
+end

data/lib/chef_fs/data_handler/group_data_handler.rb

@@ -0,0 +1,33 @@
+require 'chef_fs/data_handler/data_handler_base'
+require 'chef/api_client'
+
+module ChefFS
+  module DataHandler
+    class GroupDataHandler < DataHandlerBase
+      def normalize(group, entry)
+        defaults = {
+          'name' => remove_dot_json(entry.name),
+          'groupname' => remove_dot_json(entry.name),
+          'users' => [],
+          'actors' => [],
+          'clients' => [],
+          'groups' => [],
+        }
+        if entry.org
+          defaults['orgname'] = entry.org
+        end
+        super(group, defaults)
+      end
+
+      def preserve_key(key)
+        return key == 'name'
+      end
+
+      def chef_class
+        Chef::ApiClient
+      end
+
+      # There is no Ruby API for Chef::ApiClient
+    end
+  end
+end

data/lib/chef_fs/data_handler/user_data_handler.rb

@@ -6,7 +6,12 @@ module ChefFS
       def normalize(user, entry)
         super(user, {
           'name' => remove_dot_json(entry.name),
-          'admin' => false
+          'admin' => false,
+          'json_class' => 'Chef::WebUIUser',
+          'chef_type' => 'webui_user',
+          'salt' => nil,
+          'password' => nil,
+          'openid' => nil
         })
       end
 

data/lib/chef_fs/file_system/acl_dir.rb

@@ -0,0 +1,62 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 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_fs/file_system/base_fs_dir'
+require 'chef_fs/file_system/acl_entry'
+require 'chef_fs/file_system/operation_not_allowed_error'
+
+module ChefFS
+  module FileSystem
+    class AclDir < BaseFSDir
+      def api_path
+        parent.parent.child(name).api_path
+      end
+
+      def child(name)
+        result = @children.select { |child| child.name == name }.first if @children
+        result ||= can_have_child?(name, false) ?
+                   AclEntry.new(name, self) : NonexistentFSObject.new(name, self)
+      end
+
+      def can_have_child?(name, is_dir)
+        name =~ /\.json$/ && !is_dir
+      end
+
+      def children
+        if @children.nil?
+          # Grab the ACTUAL children (/nodes, /containers, etc.) and get their names
+          names = parent.parent.child(name).children.map { |child| child.dir? ? "#{child.name}.json" : child.name }
+          @children = names.map { |name| AclEntry.new(name, self, true) }
+        end
+        @children
+      end
+
+      def create_child(name, file_contents)
+        raise OperationNotAllowedError.new(:create_child, self)
+      end
+
+      def data_handler
+        parent.data_handler
+      end
+
+      def rest
+        parent.rest
+      end
+    end
+  end
+end

data/lib/chef_fs/file_system/acl_entry.rb

@@ -0,0 +1,54 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 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_fs/file_system/rest_list_entry'
+require 'chef_fs/file_system/not_found_error'
+require 'chef_fs/file_system/operation_not_allowed_error'
+require 'chef_fs/file_system/operation_failed_error'
+
+module ChefFS
+  module FileSystem
+    class AclEntry < RestListEntry
+      PERMISSIONS = %w(create read update delete grant)
+
+      def api_path
+        "#{super}/_acl"
+      end
+
+      def delete(recurse)
+        raise ChefFS::FileSystem::OperationNotAllowedError.new(:delete, self, e), "ACLs cannot be deleted."
+      end
+
+      def write(file_contents)
+        # ACL writes are fun.
+        acls = data_handler.normalize(JSON.parse(file_contents, :create_additions => false), self)
+        PERMISSIONS.each do |permission|
+          begin
+            rest.put_rest("#{api_path}/#{permission}", { permission => acls[permission] })
+          rescue Net::HTTPServerException => e
+            if e.response.code == "404"
+              raise ChefFS::FileSystem::NotFoundError.new(self, e)
+            else
+              raise ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "HTTP error writing: #{e}"
+            end
+          end
+        end
+      end
+    end
+  end
+end