chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/chef_fs.rb

@@ -0,0 +1,11 @@
+require 'chef/chef_fs/file_system/chef_server_root_dir'
+require 'chef/config'
+require 'chef/rest'
+
+class Chef
+  module ChefFS
+    def self.windows?
+      false
+    end
+  end
+end

data/lib/chef/chef_fs/command_line.rb

@@ -0,0 +1,232 @@
+#
+# 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'
+
+class Chef
+  module ChefFS
+    module CommandLine
+      def self.diff(pattern, a_root, b_root, recurse_depth, output_mode)
+        found_result = false
+        Chef::ChefFS::FileSystem.list_pairs(pattern, a_root, b_root) do |a, b|
+          existed = diff_entries(a, b, recurse_depth, output_mode) do |diff|
+            yield diff
+          end
+          found_result = true if existed
+        end
+        if !found_result && pattern.exact_path
+          yield "#{pattern}: No such file or directory on remote or local"
+        end
+      end
+
+      # Diff two known entries (could be files or dirs)
+      def self.diff_entries(old_entry, new_entry, recurse_depth, output_mode)
+        # If both are directories
+        if old_entry.dir?
+          if new_entry.dir?
+            if recurse_depth == 0
+              if output_mode != :name_only && output_mode != :name_status
+                yield "Common subdirectories: #{old_entry.path}\n"
+              end
+            else
+              Chef::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, output_mode) do |diff|
+                  yield diff
+                end
+              end
+            end
+
+        # If old is a directory and new is a file
+          elsif new_entry.exists?
+            if output_mode == :name_only
+              yield "#{new_entry.path_for_printing}\n"
+            elsif output_mode == :name_status
+              yield "T\t#{new_entry.path_for_printing}\n"
+            else
+              yield "File #{new_entry.path_for_printing} is a directory while file #{new_entry.path_for_printing} is a regular file\n"
+            end
+
+        # If old is a directory and new does not exist
+          elsif new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
+            if output_mode == :name_only
+              yield "#{new_entry.path_for_printing}\n"
+            elsif output_mode == :name_status
+              yield "D\t#{new_entry.path_for_printing}\n"
+            else
+              yield "Only in #{old_entry.parent.path_for_printing}: #{old_entry.name}\n"
+            end
+          end
+
+        # If new is a directory and old is a file
+        elsif new_entry.dir?
+          if old_entry.exists?
+            if output_mode == :name_only
+              yield "#{new_entry.path_for_printing}\n"
+            elsif output_mode == :name_status
+              yield "T\t#{new_entry.path_for_printing}\n"
+            else
+              yield "File #{old_entry.path_for_printing} is a regular file while file #{old_entry.path_for_printing} is a directory\n"
+            end
+
+        # If new is a directory and old does not exist
+          elsif old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
+            if output_mode == :name_only
+              yield "#{new_entry.path_for_printing}\n"
+            elsif output_mode == :name_status
+              yield "A\t#{new_entry.path_for_printing}\n"
+            else
+              yield "Only in #{new_entry.parent.path_for_printing}: #{new_entry.name}\n"
+            end
+          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
+            return old_value != :none
+          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 true
+            end
+            if !new_exists && !new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
+              return true
+            end
+
+            if output_mode == :name_only
+              yield "#{new_entry.path_for_printing}\n"
+            elsif output_mode == :name_status
+              if old_value == :none || (old_value == nil && !old_entry.exists?)
+                yield "A\t#{new_entry.path_for_printing}\n"
+              elsif new_value == :none
+                yield "D\t#{new_entry.path_for_printing}\n"
+              else
+                yield "M\t#{new_entry.path_for_printing}\n"
+              end
+            else
+              # If we haven't read the values yet, get them now.
+              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
+
+              old_path = old_entry.path_for_printing
+              new_path = new_entry.path_for_printing
+              result = ''
+              result << "diff --knife #{old_path} #{new_path}\n"
+              if old_value == :none
+                result << "new file\n"
+                old_path = "/dev/null"
+                old_value = ''
+              end
+              if new_value == :none
+                result << "deleted file\n"
+                new_path = "/dev/null"
+                new_value = ''
+              end
+              result << diff_text(old_path, new_path, old_value, new_value)
+              yield result
+            end
+          end
+        end
+        return true
+      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)
+        # Reformat JSON for a nicer diff.
+        if old_path =~ /\.json$/
+          begin
+            reformatted_old_value = canonicalize_json(old_value)
+            reformatted_new_value = canonicalize_json(new_value)
+            old_value = reformatted_old_value
+            new_value = reformatted_new_value
+          rescue
+            # If JSON parsing fails, we just won't change any values and fall back
+            # to normal diff.
+          end
+        end
+
+        # 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/file_pattern.rb

@@ -0,0 +1,312 @@
+#
+# 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'
+require 'chef/chef_fs/path_utils'
+
+class Chef
+  module ChefFS
+    #
+    # Represents a glob pattern.  This class is designed so that it can
+    # match arbitrary strings, and tell you about partial matches.
+    #
+    # Examples:
+    # * <tt>a*z</tt>
+    #   - Matches <tt>abcz</tt>
+    #   - Does not match <tt>ab/cd/ez</tt>
+    #   - Does not match <tt>xabcz</tt>
+    # * <tt>a**z</tt>
+    #   - Matches <tt>abcz</tt>
+    #   - Matches <tt>ab/cd/ez</tt>
+    #
+    # Special characters supported:
+    # * <tt>/</tt> (and <tt>\\</tt> on Windows) - directory separators
+    # * <tt>\*</tt> - match zero or more characters (but not directory separators)
+    # * <tt>\*\*</tt> - match zero or more characters, including directory separators
+    # * <tt>?</tt> - match exactly one character (not a directory separator)
+    # Only on Unix:
+    # * <tt>[abc0-9]</tt> - match one of the included characters
+    # * <tt>\\<character></tt> - escape character: match the given character
+    #
+    class FilePattern
+      # Initialize a new FilePattern with the pattern string.
+      #
+      # Raises +ArgumentError+ if empty file pattern is specified
+      def initialize(pattern)
+        @pattern = pattern
+      end
+
+      # The pattern string.
+      attr_reader :pattern
+
+      # Reports whether this pattern could match children of <tt>path</tt>.
+      # If the pattern doesn't match the path up to this point or
+      # if it matches and doesn't allow further children, this will
+      # return <tt>false</tt>.
+      #
+      # ==== Attributes
+      #
+      # * +path+ - a path to check
+      #
+      # ==== Examples
+      #
+      #   abc/def.could_match_children?('abc') == true
+      #   abc.could_match_children?('abc') == false
+      #   abc/def.could_match_children?('x') == false
+      #   a**z.could_match_children?('ab/cd') == true
+      def could_match_children?(path)
+        return false if path == '' # Empty string is not a path
+
+        argument_is_absolute = !!(path =~ /^#{Chef::ChefFS::PathUtils::regexp_path_separator}/)
+        return false if is_absolute != argument_is_absolute
+        path = path[1,path.length-1] if argument_is_absolute
+
+        path_parts = Chef::ChefFS::PathUtils::split(path)
+        # If the pattern is shorter than the path (or same size), children will be larger than the pattern, and will not match.
+        return false if regexp_parts.length <= path_parts.length && !has_double_star
+        # If the path doesn't match up to this point, children won't match either.
+        return false if path_parts.zip(regexp_parts).any? { |part,regexp| !regexp.nil? && !regexp.match(part) }
+        # Otherwise, it's possible we could match: the path matches to this point, and the pattern is longer than the path.
+        # TODO There is one edge case where the double star comes after some characters like abc**def--we could check whether the next
+        # bit of path starts with abc in that case.
+        return true
+      end
+
+      # Returns the immediate child of a path that would be matched
+      # if this FilePattern was applied.  If more than one child
+      # could match, this method returns nil.
+      #
+      # ==== Attributes
+      #
+      # * +path+ - The path to look for an exact child name under.
+      #
+      # ==== Returns
+      #
+      # The next directory in the pattern under the given path.
+      # If the directory part could match more than one child, it
+      # returns +nil+.
+      #
+      # ==== Examples
+      #
+      #   abc/def.exact_child_name_under('abc') == 'def'
+      #   abc/def/ghi.exact_child_name_under('abc') == 'def'
+      #   abc/*/ghi.exact_child_name_under('abc') == nil
+      #   abc/*/ghi.exact_child_name_under('abc/def') == 'ghi'
+      #   abc/**/ghi.exact_child_name_under('abc/def') == nil
+      #
+      # This method assumes +could_match_children?(path)+ is +true+.
+      def exact_child_name_under(path)
+        path = path[1,path.length-1] if !!(path =~ /^#{Chef::ChefFS::PathUtils::regexp_path_separator}/)
+        dirs_in_path = Chef::ChefFS::PathUtils::split(path).length
+        return nil if exact_parts.length <= dirs_in_path
+        return exact_parts[dirs_in_path]
+      end
+
+      # If this pattern represents an exact path, returns the exact path.
+      #
+      #   abc/def.exact_path == 'abc/def'
+      #   abc/*def.exact_path == 'abc/def'
+      #   abc/x\\yz.exact_path == 'abc/xyz'
+      def exact_path
+        return nil if has_double_star || exact_parts.any? { |part| part.nil? }
+        result = Chef::ChefFS::PathUtils::join(*exact_parts)
+        is_absolute ? Chef::ChefFS::PathUtils::join('', result) : result
+      end
+
+      # Returns the normalized version of the pattern, with / as the directory
+      # separator, and "." and ".." removed.
+      #
+      # This does not presently change things like \b to b, but in the future
+      # it might.
+      def normalized_pattern
+        calculate
+        @normalized_pattern
+      end
+
+      # Tell whether this pattern matches absolute, or relative paths
+      def is_absolute
+        calculate
+        @is_absolute
+      end
+
+      # Returns <tt>true+ if this pattern matches the path, <tt>false+ otherwise.
+      #
+      #   abc/*/def.match?('abc/foo/def') == true
+      #   abc/*/def.match?('abc/foo') == false
+      def match?(path)
+        argument_is_absolute = !!(path =~ /^#{Chef::ChefFS::PathUtils::regexp_path_separator}/)
+        return false if is_absolute != argument_is_absolute
+        path = path[1,path.length-1] if argument_is_absolute
+        !!regexp.match(path)
+      end
+
+      # Returns the string pattern
+      def to_s
+        pattern
+      end
+
+      # Given a relative file pattern and a directory, makes a new file pattern
+      # starting with the directory.
+      #
+      #   FilePattern.relative_to('/usr/local', 'bin/*grok') == FilePattern.new('/usr/local/bin/*grok')
+      #
+      # BUG: this does not support patterns starting with <tt>..</tt>
+      def self.relative_to(dir, pattern)
+        return FilePattern.new(pattern) if pattern =~ /^#{Chef::ChefFS::PathUtils::regexp_path_separator}/
+        FilePattern.new(Chef::ChefFS::PathUtils::join(dir, pattern))
+      end
+
+    private
+
+      def regexp
+        calculate
+        @regexp
+      end
+
+      def regexp_parts
+        calculate
+        @regexp_parts
+      end
+
+      def exact_parts
+        calculate
+        @exact_parts
+      end
+
+      def has_double_star
+        calculate
+        @has_double_star
+      end
+
+      def calculate
+        if !@regexp
+          @is_absolute = !!(@pattern =~ /^#{Chef::ChefFS::PathUtils::regexp_path_separator}/)
+
+          full_regexp_parts = []
+          normalized_parts = []
+          @regexp_parts = []
+          @exact_parts = []
+          @has_double_star = false
+
+          Chef::ChefFS::PathUtils::split(pattern).each do |part|
+            regexp, exact, has_double_star = FilePattern::pattern_to_regexp(part)
+            if has_double_star
+              @has_double_star = true
+            end
+
+            # Skip // and /./ (pretend it's not there)
+            if exact == '' || exact == '.'
+              next
+            end
+
+            # Back up when you see .. (unless the prior part has ** in it, in which case .. must be preserved)
+            if exact == '..'
+              if @is_absolute && normalized_parts.length == 0
+                # If we are at the root, just pretend the .. isn't there
+                next
+              elsif normalized_parts.length > 0
+                regexp_prev, exact_prev, has_double_star_prev = FilePattern.pattern_to_regexp(normalized_parts[-1])
+                if has_double_star_prev
+                  raise ArgumentError, ".. overlapping a ** is unsupported"
+                end
+                full_regexp_parts.pop
+                normalized_parts.pop
+                if !@has_double_star
+                  @regexp_parts.pop
+                  @exact_parts.pop
+                end
+                next
+              end
+            end
+
+            # Build up the regexp
+            full_regexp_parts << regexp
+            normalized_parts << part
+            if !@has_double_star
+              @regexp_parts << Regexp.new("^#{regexp}$")
+              @exact_parts << exact
+            end
+          end
+
+          @regexp = Regexp.new("^#{full_regexp_parts.join(Chef::ChefFS::PathUtils::regexp_path_separator)}$")
+          @normalized_pattern = Chef::ChefFS::PathUtils.join(*normalized_parts)
+          @normalized_pattern = Chef::ChefFS::PathUtils.join('', @normalized_pattern) if @is_absolute
+        end
+      end
+
+      def self.pattern_special_characters
+        if Chef::ChefFS::windows?
+          @pattern_special_characters ||= /(\*\*|\*|\?|[\*\?\.\|\(\)\[\]\{\}\+\\\\\^\$])/
+        else
+          # Unix also supports character regexes and backslashes
+          @pattern_special_characters ||= /(\\.|\[[^\]]+\]|\*\*|\*|\?|[\*\?\.\|\(\)\[\]\{\}\+\\\\\^\$])/
+        end
+        @pattern_special_characters
+      end
+
+      def self.regexp_escape_characters
+        [ '[', '\\', '^', '$', '.', '|', '?', '*', '+', '(', ')', '{', '}' ]
+      end
+
+      def self.pattern_to_regexp(pattern)
+        regexp = ""
+        exact = ""
+        has_double_star = false
+        pattern.split(pattern_special_characters).each_with_index do |part, index|
+          # Odd indexes from the split are symbols.  Even are normal bits.
+          if index % 2 == 0
+            exact << part if !exact.nil?
+            regexp << part
+          else
+            case part
+            # **, * and ? happen on both platforms.
+            when '**'
+              exact = nil
+              has_double_star = true
+              regexp << '.*'
+            when '*'
+              exact = nil
+              regexp << '[^\/]*'
+            when '?'
+              exact = nil
+              regexp << '.'
+            else
+              if part[0,1] == '\\' && part.length == 2
+                # backslash escapes are only supported on Unix, and are handled here by leaving the escape on (it means the same thing in a regex)
+                exact << part[1,1] if !exact.nil?
+                if regexp_escape_characters.include?(part[1,1])
+                  regexp << part
+                else
+                  regexp << part[1,1]
+                end
+              elsif part[0,1] == '[' && part.length > 1
+                # [...] happens only on Unix, and is handled here by *not* backslashing (it means the same thing in and out of regex)
+                exact = nil
+                regexp << part
+              else
+                exact += part if !exact.nil?
+                regexp << "\\#{part}"
+              end
+            end
+          end
+        end
+        [regexp, exact, has_double_star]
+      end
+    end
+  end
+end