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

data/lib/chef/chef_fs/command_line.rb

@@ -0,0 +1,284 @@
+#
+# 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/chef_fs/file_system'
+require 'chef/chef_fs/file_system/operation_failed_error'
+require 'chef/chef_fs/file_system/operation_not_allowed_error'
+
+class Chef
+  module ChefFS
+    module CommandLine
+
+      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).each 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)
+
+          case type
+          when :common_subdirectories
+            if output_mode != :name_only && output_mode != :name_status
+              yield "Common subdirectories: #{new_path}\n"
+            end
+
+          when :directory_to_file
+            next if diff_filter && diff_filter !~ /T/
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "T\t#{new_path}\n"
+            else
+              yield "File #{old_path} is a directory while file #{new_path} is a regular file\n"
+            end
+
+          when :file_to_directory
+            next if diff_filter && diff_filter !~ /T/
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "T\t#{new_path}\n"
+            else
+              yield "File #{old_path} is a regular file while file #{new_path} is a directory\n"
+            end
+
+          when :deleted
+            next if diff_filter && diff_filter !~ /D/
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "D\t#{new_path}\n"
+            elsif old_value
+              result = "diff --knife #{old_path} #{new_path}\n"
+              result << "deleted file\n"
+              result << diff_text(old_path, '/dev/null', old_value, '')
+              yield result
+            else
+              yield "Only in #{format_path.call(old_entry.parent)}: #{old_entry.name}\n"
+            end
+
+          when :added
+            next if diff_filter && diff_filter !~ /A/
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "A\t#{new_path}\n"
+            elsif new_value
+              result = "diff --knife #{old_path} #{new_path}\n"
+              result << "new file\n"
+              result << diff_text('/dev/null', new_path, '', new_value)
+              yield result
+            else
+              yield "Only in #{format_path.call(new_entry.parent)}: #{new_entry.name}\n"
+            end
+
+          when :modified
+            next if diff_filter && diff_filter !~ /M/
+            if output_mode == :name_only
+              yield "#{new_path}\n"
+            elsif output_mode == :name_status
+              yield "M\t#{new_path}\n"
+            else
+              result = "diff --knife #{old_path} #{new_path}\n"
+              result << diff_text(old_path, new_path, old_value, new_value)
+              yield result
+            end
+
+          when :both_nonexistent
+          when :added_cannot_upload
+          when :deleted_cannot_download
+          when :same
+            # Skip these silently
+          when :error
+            if error.is_a?(Chef::ChefFS::FileSystem::OperationFailedError)
+              ui.error "#{format_path.call(error.entry)} failed to #{error.operation}: #{error.message}" if ui
+              error = true
+            elsif error.is_a?(Chef::ChefFS::FileSystem::OperationNotAllowedError)
+              ui.error "#{format_path.call(error.entry)} #{error.reason}." if ui
+            else
+              raise error
+            end
+          end
+        end
+        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, old_root, new_root, recurse_depth, get_content)
+        Chef::ChefFS::Parallelizer.parallelize(Chef::ChefFS::FileSystem.list_pairs(pattern, old_root, new_root), :flatten => true) do |old_entry, new_entry|
+          diff_entries(old_entry, new_entry, recurse_depth, get_content)
+        end
+      end
+
+      # 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
+              return [ [ :common_subdirectories, old_entry, new_entry ] ]
+            else
+              return Chef::ChefFS::Parallelizer.parallelize(Chef::ChefFS::FileSystem.child_pairs(old_entry, new_entry), :flatten => true) do |old_child, new_child|
+                Chef::ChefFS::CommandLine.diff_entries(old_child, new_child, recurse_depth ? recurse_depth - 1 : nil, get_content)
+              end
+            end
+
+          # If old is a directory and new is a file
+          elsif new_entry.exists?
+            return [ [ :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?)
+            return [ [ :deleted, old_entry, new_entry ] ]
+
+          # If the new entry does not and *cannot* exist, report that.
+          else
+            return [ [ :new_cannot_upload, old_entry, new_entry ] ]
+          end
+
+        # If new is a directory and old is a file
+        elsif new_entry.dir?
+          if old_entry.exists?
+            return [ [ :file_to_directory, old_entry, new_entry ] ]
+
+          # If new is a directory and old does not exist
+          elsif old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
+            return [ [ :added, old_entry, new_entry ] ]
+
+          # If the new entry does not and *cannot* exist, report that.
+          else
+            return [ [ :old_cannot_upload, old_entry, new_entry ] ]
+          end
+
+        # Neither is a directory, so they are diffable with file diff
+        else
+          are_same, old_value, new_value = Chef::ChefFS::FileSystem.compare(old_entry, new_entry)
+          if are_same
+            if old_value == :none
+              return [ [ :both_nonexistent, old_entry, new_entry ] ]
+            else
+              return [ [ :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
+            end
+
+            if new_value == :none
+              new_exists = false
+            elsif new_value.nil?
+              new_exists = new_entry.exists?
+            else
+              new_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?)
+              return [ [ :old_cannot_upload, old_entry, new_entry ] ]
+            end
+            if !new_exists && !new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
+              return [ [ :new_cannot_upload, old_entry, new_entry ] ]
+            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 Chef::ChefFS::FileSystem::NotFoundError
+                old_value = :none
+              end
+              begin
+                new_value = new_entry.read if new_value.nil?
+              rescue Chef::ChefFS::FileSystem::NotFoundError
+                new_value = :none
+              end
+            end
+
+            if old_value == :none || (old_value == nil && !old_entry.exists?)
+              return [ [ :added, old_entry, new_entry, old_value, new_value ] ]
+            elsif new_value == :none
+              return [ [ :deleted, old_entry, new_entry, old_value, new_value ] ]
+            else
+              return [ [ :modified, old_entry, new_entry, old_value, new_value ] ]
+            end
+          end
+        end
+      rescue Chef::ChefFS::FileSystem::FileSystemError => e
+        return [ [ :error, old_entry, new_entry, nil, nil, e ] ]
+      end
+
+      private
+
+      def self.sort_keys(json_object)
+        if json_object.is_a?(Array)
+          json_object.map { |o| sort_keys(o) }
+        elsif json_object.is_a?(Hash)
+          new_hash = {}
+          json_object.keys.sort.each { |key| new_hash[key] = sort_keys(json_object[key]) }
+          new_hash
+        else
+          json_object
+        end
+      end
+
+      def self.canonicalize_json(json_text)
+        parsed_json = JSON.parse(json_text, :create_additions => false)
+        sorted_json = sort_keys(parsed_json)
+        JSON.pretty_generate(sorted_json)
+      end
+
+      def self.diff_text(old_path, new_path, old_value, new_value)
+        # Copy to tempfiles before diffing
+        # TODO don't copy things that are already in files!  Or find an in-memory diff algorithm
+        begin
+          new_tempfile = Tempfile.new("new")
+          new_tempfile.write(new_value)
+          new_tempfile.close
+
+          begin
+            old_tempfile = Tempfile.new("old")
+            old_tempfile.write(old_value)
+            old_tempfile.close
+
+            result = `diff -u #{old_tempfile.path} #{new_tempfile.path}`
+            result = result.gsub(/^--- #{old_tempfile.path}/, "--- #{old_path}")
+            result = result.gsub(/^\+\+\+ #{new_tempfile.path}/, "+++ #{new_path}")
+            result
+          ensure
+            old_tempfile.close!
+          end
+        ensure
+          new_tempfile.close!
+        end
+      end
+    end
+  end
+end

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