chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/chef_fs/config.rb

@@ -0,0 +1,205 @@
+#
+# 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/chef_fs/path_utils'
+
+class Chef
+  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/chef_fs/file_system/chef_server_root_dir'
+        Chef::ChefFS::FileSystem::ChefServerRootDir.new("remote", @chef_config)
+      end
+
+      def local_fs
+        @local_fs ||= create_local_fs
+      end
+
+      def create_local_fs
+        require 'chef/chef_fs/file_system/chef_repository_file_system_root_dir'
+        Chef::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 = Chef::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 = Chef::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 = Chef::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 = Chef::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 ||= begin
+          if @chef_config[:chef_repo_path]
+            server_path(File.expand_path(@cwd))
+          else
+            nil
+          end
+        end
+      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
+
+      def require_chef_repo_path
+        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
+      end
+
+      private
+
+      def object_paths
+        @object_paths ||= begin
+          require_chef_repo_path
+
+          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
+end

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