chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/chef_fs/data_handler/acl_data_handler.rb

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

data/lib/chef/chef_fs/data_handler/client_data_handler.rb

@@ -0,0 +1,38 @@
+require 'chef/chef_fs/data_handler/data_handler_base'
+require 'chef/api_client'
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class ClientDataHandler < DataHandlerBase
+        def normalize(client, entry)
+          defaults = {
+            'name' => remove_dot_json(entry.name),
+            'clientname' => remove_dot_json(entry.name),
+            'orgname' => entry.org,
+            'admin' => false,
+            'validator' => false,
+            'chef_type' => 'client'
+          }
+          if entry.org
+            defaults['orgname'] = entry.org
+          end
+          result = normalize_hash(client, defaults)
+          # You can NOT send json_class, or it will fail
+          result.delete('json_class')
+          result
+        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
+end

data/lib/chef/chef_fs/data_handler/container_data_handler.rb

@@ -0,0 +1,29 @@
+require 'chef/chef_fs/data_handler/data_handler_base'
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class ContainerDataHandler < DataHandlerBase
+        def normalize(container, entry)
+          normalize_hash(container, {
+            'containername' => remove_dot_json(entry.name),
+            'containerpath' => remove_dot_json(entry.name)
+          })
+        end
+
+        def preserve_key(key)
+          return key == 'containername'
+        end
+
+        def verify_integrity(object, entry, &on_error)
+          base_name = remove_dot_json(entry.name)
+          if object['containername'] != base_name
+            on_error.call("Name in #{entry.path_for_printing} must be '#{base_name}' (is '#{object['name']}')")
+          end
+        end
+
+        # There is no chef_class for users, nor does to_ruby work.
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/cookbook_data_handler.rb

@@ -0,0 +1,38 @@
+require 'chef/chef_fs/data_handler/data_handler_base'
+require 'chef/cookbook/metadata'
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class CookbookDataHandler < DataHandlerBase
+        def normalize(cookbook, entry)
+          version = entry.name
+          name = entry.parent.name
+          result = normalize_hash(cookbook, {
+            'name' => "#{name}-#{version}",
+            'version' => version,
+            'cookbook_name' => name,
+            'json_class' => 'Chef::CookbookVersion',
+            'chef_type' => 'cookbook_version',
+            'frozen?' => false,
+            'metadata' => {}
+          })
+          result['metadata'] = normalize_hash(result['metadata'], {
+            'version' => version,
+            'name' => name
+          })
+        end
+
+        def preserve_key(key)
+          return key == 'cookbook_name' || key == 'version'
+        end
+
+        def chef_class
+          Chef::Cookbook::Metadata
+        end
+
+        # Not using this yet, so not sure if to_ruby will be useful.
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/data_bag_item_data_handler.rb

@@ -0,0 +1,56 @@
+require 'chef/chef_fs/data_handler/data_handler_base'
+require 'chef/data_bag_item'
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class DataBagItemDataHandler < DataHandlerBase
+        def normalize(data_bag_item, entry)
+          # If it's wrapped with raw_data, unwrap it.
+          if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
+            data_bag_item = data_bag_item['raw_data']
+          end
+          # chef_type and data_bag come back in PUT and POST results, but we don't
+          # use those in knife-essentials.
+          normalize_hash(data_bag_item, {
+            'id' => remove_dot_json(entry.name)
+          })
+        end
+
+        def normalize_for_post(data_bag_item, entry)
+          if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
+            data_bag_item = data_bag_item['raw_data']
+          end
+          {
+            "name" => "data_bag_item_#{entry.parent.name}_#{remove_dot_json(entry.name)}",
+            "json_class" => "Chef::DataBagItem",
+            "chef_type" => "data_bag_item",
+            "data_bag" => entry.parent.name,
+            "raw_data" => normalize(data_bag_item, entry)
+          }
+        end
+
+        def normalize_for_put(data_bag_item, entry)
+          normalize_for_post(data_bag_item, entry)
+        end
+
+        def preserve_key(key)
+          return key == 'id'
+        end
+
+        def chef_class
+          Chef::DataBagItem
+        end
+
+        def verify_integrity(object, entry, &on_error)
+          base_name = remove_dot_json(entry.name)
+          if object['raw_data']['id'] != base_name
+            on_error.call("ID in #{entry.path_for_printing} must be '#{base_name}' (is '#{object['raw_data']['id']}')")
+          end
+        end
+
+        # Data bags do not support .rb files (or if they do, it's undocumented)
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/data_handler_base.rb

@@ -0,0 +1,128 @@
+class Chef
+  module ChefFS
+    module DataHandler
+      class DataHandlerBase
+        def minimize(object, entry)
+          default_object = default(entry)
+          object.each_pair do |key, value|
+            if default_object[key] == value && !preserve_key(key)
+              object.delete(key)
+            end
+          end
+          object
+        end
+
+        def remove_dot_json(name)
+          if name.length < 5 || name[-5,5] != ".json"
+            raise "Invalid name #{path}: must end in .json"
+          end
+          name[0,name.length-5]
+        end
+
+        def preserve_key(key)
+          false
+        end
+
+        def default(entry)
+          normalize({}, entry)
+        end
+
+        def normalize_hash(object, defaults)
+          # Make a normalized result in the specified order for diffing
+          result = {}
+          defaults.each_pair do |key, default|
+            result[key] = object.has_key?(key) ? object[key] : default
+          end
+          object.each_pair do |key, value|
+            result[key] = value if !result.has_key?(key)
+          end
+          result
+        end
+
+        def normalize_for_post(object, entry)
+          normalize(object, entry)
+        end
+
+        def normalize_for_put(object, entry)
+          normalize(object, entry)
+        end
+
+        def normalize_run_list(run_list)
+          run_list.map{|item|
+            case item.to_s
+            when /^recipe\[.*\]$/
+              item # explicit recipe
+            when /^role\[.*\]$/
+              item # explicit role
+            else
+              "recipe[#{item}]"
+            end
+          }.uniq
+        end
+
+        def from_ruby(ruby)
+          chef_class.from_file(ruby).to_hash
+        end
+
+        def chef_object(object)
+          chef_class.json_create(object)
+        end
+
+        def to_ruby(object)
+          raise NotImplementedError
+        end
+
+        def chef_class
+          raise NotImplementedError
+        end
+
+        def to_ruby_keys(object, keys)
+          result = ''
+          keys.each do |key|
+            if object[key]
+              if object[key].is_a?(Hash)
+                if object[key].size > 0
+                  result << key
+                  first = true
+                  object[key].each_pair do |k,v|
+                    if first
+                      first = false
+                    else
+                      result << ' '*key.length
+                    end
+                    result << " #{k.inspect} => #{v.inspect}\n"
+                  end
+                end
+              elsif object[key].is_a?(Array)
+                if object[key].size > 0
+                  result << key
+                  first = true
+                  object[key].each do |value|
+                    if first
+                      first = false
+                    else
+                      result << ", "
+                    end
+                    result << value.inspect
+                  end
+                  result << "\n"
+                end
+              elsif !object[key].nil?
+                result << "#{key} #{object[key].inspect}\n"
+              end
+            end
+          end
+          result
+        end
+
+        def verify_integrity(object, entry, &on_error)
+          base_name = remove_dot_json(entry.name)
+          if object['name'] != base_name
+            on_error.call("Name must be '#{base_name}' (is '#{object['name']}')")
+          end
+        end
+
+      end # class DataHandlerBase
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/environment_data_handler.rb

@@ -0,0 +1,40 @@
+require 'chef/chef_fs/data_handler/data_handler_base'
+require 'chef/environment'
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class EnvironmentDataHandler < DataHandlerBase
+        def normalize(environment, entry)
+          normalize_hash(environment, {
+            'name' => remove_dot_json(entry.name),
+            'description' => '',
+            'cookbook_versions' => {},
+            'default_attributes' => {},
+            'override_attributes' => {},
+            'json_class' => 'Chef::Environment',
+            'chef_type' => 'environment'
+          })
+        end
+
+        def preserve_key(key)
+          return key == 'name'
+        end
+
+        def chef_class
+          Chef::Environment
+        end
+
+        def to_ruby(object)
+          result = to_ruby_keys(object, %w(name description default_attributes override_attributes))
+          if object['cookbook_versions']
+            object['cookbook_versions'].each_pair do |name, version|
+              result << "cookbook #{name.inspect}, #{version.inspect}"
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/group_data_handler.rb

@@ -0,0 +1,51 @@
+require 'chef/chef_fs/data_handler/data_handler_base'
+require 'chef/api_client'
+
+class Chef
+  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' => [],
+            'clients' => [],
+            'groups' => [],
+          }
+          if entry.org
+            defaults['orgname'] = entry.org
+          end
+          result = normalize_hash(group, defaults)
+          if result['actors'] && result['actors'].sort.uniq == (result['users'] + result['clients']).sort.uniq
+            result.delete('actors')
+          end
+          result
+        end
+
+        def normalize_for_put(group, entry)
+          result = super(group, entry)
+          result['actors'] = {
+            'users' => result['users'],
+            'clients' => result['clients'],
+            'groups' => result['groups']
+          }
+          result.delete('users')
+          result.delete('clients')
+          result.delete('groups')
+          result
+        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
+end

data/lib/chef/chef_fs/data_handler/node_data_handler.rb

@@ -0,0 +1,36 @@
+require 'chef/chef_fs/data_handler/data_handler_base'
+require 'chef/node'
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class NodeDataHandler < DataHandlerBase
+        def normalize(node, entry)
+          result = normalize_hash(node, {
+            'name' => remove_dot_json(entry.name),
+            'json_class' => 'Chef::Node',
+            'chef_type' => 'node',
+            'chef_environment' => '_default',
+            'override' => {},
+            'normal' => {},
+            'default' => {},
+            'automatic' => {},
+            'run_list' => []
+          })
+          result['run_list'] = normalize_run_list(result['run_list'])
+          result
+        end
+
+        def preserve_key(key)
+          return key == 'name'
+        end
+
+        def chef_class
+          Chef::Node
+        end
+
+        # Nodes do not support .rb files
+      end
+    end
+  end
+end