chef 12.4.0.rc.0-universal-mingw32

data/lib/chef/config.rb

@@ -0,0 +1,54 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Author:: Mark Mzyk (<mmzyk@opscode.com>)
+# Author:: Kyle Goodwin (<kgoodwin@primerevenue.com>)
+# Copyright:: Copyright (c) 2008 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-config/logger'
+
+# DI our logger into ChefConfig before we load the config. Some defaults are
+# auto-detected, and this emits log messages on some systems, all of which will
+# occur at require-time. So we need to set the logger first.
+ChefConfig.logger = Chef::Log
+
+require 'chef-config/config'
+
+require 'chef/platform/query_helpers'
+
+class Chef
+  Config = ChefConfig::Config
+
+  # We re-open ChefConfig::Config to add additional settings. Generally,
+  # everything should go in chef-config so it's shared with whoever uses that.
+  # We make execeptions to that rule when:
+  # * The functionality isn't likely to be useful outside of Chef
+  # * The functionality makes use of a dependency we don't want to add to chef-config
+  class Config
+
+    default :event_loggers do
+      evt_loggers = []
+      if ChefConfig.windows? and not Chef::Platform.windows_server_2003?
+        evt_loggers << :win_evt
+      end
+      evt_loggers
+    end
+
+  end
+end
+

data/lib/chef/config_fetcher.rb

@@ -0,0 +1,64 @@
+require 'chef/application'
+require 'chef/chef_fs/path_utils'
+require 'chef/http/simple'
+require 'chef/json_compat'
+
+class Chef
+  class ConfigFetcher
+
+    attr_reader :config_location
+
+    def initialize(config_location)
+      @config_location = config_location
+    end
+
+    def fetch_json
+      config_data = read_config
+      begin
+        Chef::JSONCompat.from_json(config_data)
+      rescue Chef::Exceptions::JSON::ParseError => error
+        Chef::Application.fatal!("Could not parse the provided JSON file (#{config_location}): " + error.message, 2)
+      end
+    end
+
+    def read_config
+      if remote_config?
+        fetch_remote_config
+      else
+        read_local_config
+      end
+    end
+
+    def fetch_remote_config
+      http.get("")
+    rescue SocketError, SystemCallError, Net::HTTPServerException => error
+      Chef::Application.fatal!("Cannot fetch config '#{config_location}': '#{error.class}: #{error.message}", 2)
+    end
+
+    def read_local_config
+      ::File.read(config_location)
+    rescue Errno::ENOENT => error
+      Chef::Application.fatal!("Cannot load configuration from #{config_location}", 2)
+    rescue Errno::EACCES => error
+      Chef::Application.fatal!("Permissions are incorrect on #{config_location}. Please chmod a+r #{config_location}", 2)
+    end
+
+    def config_missing?
+      return false if remote_config?
+
+      # Check if the config file exists
+      Pathname.new(config_location).realpath.to_s
+      false
+    rescue Errno::ENOENT
+      return true
+    end
+
+    def http
+      Chef::HTTP::Simple.new(config_location)
+    end
+
+    def remote_config?
+      !!(config_location =~ %r{^(http|https)://})
+    end
+  end
+end

data/lib/chef/cookbook/chefignore.rb

@@ -0,0 +1,75 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2011 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.
+#
+
+class Chef
+  class Cookbook
+    class Chefignore
+
+      COMMENTS_AND_WHITESPACE = /^\s*(?:#.*)?$/
+
+      attr_reader :ignores
+
+      def initialize(ignore_file_or_repo)
+        # Check the 'ignore_file_or_repo' path first and then look in the parent directory
+        # to handle both the chef repo cookbook layout and a standalone cookbook
+        @ignore_file = find_ignore_file(ignore_file_or_repo)
+        @ignore_file = find_ignore_file(File.dirname(ignore_file_or_repo)) unless readable_file_or_symlink?(@ignore_file)
+
+        @ignores = parse_ignore_file
+      end
+
+      def remove_ignores_from(file_list)
+        Array(file_list).inject([]) do |unignored, file|
+          ignored?(file) ? unignored : unignored << file
+        end
+      end
+
+      def ignored?(file_name)
+        @ignores.any? {|glob| File.fnmatch?(glob, file_name)}
+      end
+
+      private
+
+      def parse_ignore_file
+        ignore_globs = []
+        if readable_file_or_symlink?(@ignore_file)
+          File.foreach(@ignore_file) do |line|
+            ignore_globs << line.strip unless line =~ COMMENTS_AND_WHITESPACE
+          end
+        else
+          Chef::Log.debug("No chefignore file found at #@ignore_file no files will be ignored")
+        end
+        ignore_globs
+      end
+
+      def find_ignore_file(path)
+        if File.basename(path) =~ /chefignore/
+          path
+        else
+          File.join(path, 'chefignore')
+        end
+      end
+
+      def readable_file_or_symlink?(path)
+        File.exist?(@ignore_file) && File.readable?(@ignore_file) &&
+          (File.file?(@ignore_file) || File.symlink?(@ignore_file))
+      end
+    end
+  end
+end
+

data/lib/chef/cookbook/cookbook_collection.rb

@@ -0,0 +1,45 @@
+#--
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2010 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/mash'
+
+class Chef
+  # == Chef::CookbookCollection
+  # This class is the consistent interface for a node to obtain its
+  # cookbooks by name.
+  #
+  # This class is basically a glorified Hash, but since there are
+  # several ways this cookbook information is collected,
+  # (e.g. CookbookLoader for solo, hash of auto-vivified Cookbook
+  # objects for lazily-loaded remote cookbooks), it gets transformed
+  # into this.
+  class CookbookCollection < Mash
+
+    # The input is a mapping of cookbook name to CookbookVersion objects. We
+    # simply extract them
+    def initialize(cookbook_versions={})
+      super() do |hash, key|
+        raise Chef::Exceptions::CookbookNotFound, "Cookbook #{key} not found. " <<
+          "If you're loading #{key} from another cookbook, make sure you configure the dependency in your metadata"
+      end
+      cookbook_versions.each{ |cookbook_name, cookbook_version| self[cookbook_name] = cookbook_version }
+    end
+
+  end
+end

data/lib/chef/cookbook/cookbook_version_loader.rb

@@ -0,0 +1,301 @@
+
+require 'chef/cookbook_version'
+require 'chef/cookbook/chefignore'
+require 'chef/cookbook/metadata'
+require 'chef/util/path_helper'
+
+class Chef
+  class Cookbook
+    class CookbookVersionLoader
+
+      FILETYPES_SUBJECT_TO_IGNORE = [ :attribute_filenames,
+                                      :definition_filenames,
+                                      :recipe_filenames,
+                                      :template_filenames,
+                                      :file_filenames,
+                                      :library_filenames,
+                                      :resource_filenames,
+                                      :provider_filenames]
+
+      UPLOADED_COOKBOOK_VERSION_FILE = ".uploaded-cookbook-version.json".freeze
+
+      attr_reader :cookbook_settings
+      attr_reader :cookbook_paths
+      attr_reader :metadata_filenames
+      attr_reader :frozen
+      attr_reader :uploaded_cookbook_version_file
+
+      attr_reader :cookbook_path
+
+      # The cookbook's name as inferred from its directory.
+      attr_reader :inferred_cookbook_name
+
+      attr_reader :metadata_error
+
+      def initialize(path, chefignore=nil)
+        @cookbook_path = File.expand_path( path ) # cookbook_path from which this was loaded
+        # We keep a list of all cookbook paths that have been merged in
+        @cookbook_paths = [ cookbook_path ]
+
+        @inferred_cookbook_name = File.basename( path )
+        @chefignore = chefignore
+        @metadata = nil
+        @relative_path = /#{Regexp.escape(@cookbook_path)}\/(.+)$/
+        @metadata_loaded = false
+        @cookbook_settings = {
+          :attribute_filenames  => {},
+          :definition_filenames => {},
+          :recipe_filenames     => {},
+          :template_filenames   => {},
+          :file_filenames       => {},
+          :library_filenames    => {},
+          :resource_filenames   => {},
+          :provider_filenames   => {},
+          :root_filenames       => {}
+        }
+
+        @metadata_filenames = []
+        @metadata_error = nil
+      end
+
+      # Load the cookbook. Raises an error if the cookbook_path given to the
+      # constructor doesn't point to a valid cookbook.
+      def load!
+        file_paths_map = load
+
+        if empty?
+          raise Exceptions::CookbookNotFoundInRepo, "The directory #{cookbook_path} does not contain a cookbook"
+        end
+        file_paths_map
+      end
+
+      # Load the cookbook. Does not raise an error if given a non-cookbook
+      # directory as the cookbook_path. This behavior is provided for
+      # compatibility, it is recommended to use #load! instead.
+      def load
+        metadata # force lazy evaluation to occur
+
+        # re-raise any exception that occurred when reading the metadata
+        raise_metadata_error!
+
+        load_as(:attribute_filenames, 'attributes', '*.rb')
+        load_as(:definition_filenames, 'definitions', '*.rb')
+        load_as(:recipe_filenames, 'recipes', '*.rb')
+        load_recursively_as(:library_filenames, 'libraries', '*.rb')
+        load_recursively_as(:template_filenames, "templates", "*")
+        load_recursively_as(:file_filenames, "files", "*")
+        load_recursively_as(:resource_filenames, "resources", "*.rb")
+        load_recursively_as(:provider_filenames, "providers", "*.rb")
+        load_root_files
+
+        remove_ignored_files
+
+        if empty?
+          Chef::Log.warn "found a directory #{cookbook_name} in the cookbook path, but it contains no cookbook files. skipping."
+        end
+        @cookbook_settings
+      end
+
+      alias :load_cookbooks :load
+
+      def metadata_filenames
+        return @metadata_filenames unless @metadata_filenames.empty?
+        if File.exists?(File.join(cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE))
+          @uploaded_cookbook_version_file = File.join(cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE)
+        end
+
+        if File.exists?(File.join(cookbook_path, "metadata.rb"))
+          @metadata_filenames << File.join(cookbook_path, "metadata.rb")
+        elsif File.exists?(File.join(cookbook_path, "metadata.json"))
+          @metadata_filenames << File.join(cookbook_path, "metadata.json")
+        elsif @uploaded_cookbook_version_file
+          @metadata_filenames << @uploaded_cookbook_version_file
+        end
+
+        # Set frozen based on .uploaded-cookbook-version.json
+        set_frozen
+        @metadata_filenames
+      end
+
+      def cookbook_version
+        return nil if empty?
+
+        Chef::CookbookVersion.new(cookbook_name, *cookbook_paths).tap do |c|
+          c.attribute_filenames  = cookbook_settings[:attribute_filenames].values
+          c.definition_filenames = cookbook_settings[:definition_filenames].values
+          c.recipe_filenames     = cookbook_settings[:recipe_filenames].values
+          c.template_filenames   = cookbook_settings[:template_filenames].values
+          c.file_filenames       = cookbook_settings[:file_filenames].values
+          c.library_filenames    = cookbook_settings[:library_filenames].values
+          c.resource_filenames   = cookbook_settings[:resource_filenames].values
+          c.provider_filenames   = cookbook_settings[:provider_filenames].values
+          c.root_filenames       = cookbook_settings[:root_filenames].values
+          c.metadata_filenames   = metadata_filenames
+          c.metadata             = metadata
+
+          c.freeze_version if @frozen
+        end
+      end
+
+      def cookbook_name
+        # The `name` attribute is now required in metadata, so
+        # inferred_cookbook_name generally should not be used. Per CHEF-2923,
+        # we have to not raise errors in cookbook metadata immediately, so that
+        # users can still `knife cookbook upload some-cookbook` when an
+        # unrelated cookbook has an error in its metadata.  This situation
+        # could prevent us from reading the `name` attribute from the metadata
+        # entirely, but the name is used as a hash key in CookbookLoader, so we
+        # fall back to the inferred name here.
+        (metadata.name || @inferred_cookbook_name).to_sym
+      end
+
+      # Generates the Cookbook::Metadata object
+      def metadata
+        return @metadata unless @metadata.nil?
+
+        @metadata = Chef::Cookbook::Metadata.new
+
+        metadata_filenames.each do |metadata_file|
+          case metadata_file
+          when /\.rb$/
+            apply_ruby_metadata(metadata_file)
+          when @uploaded_cookbook_version_file
+            apply_json_cookbook_version_metadata(metadata_file)
+          when /\.json$/
+            apply_json_metadata(metadata_file)
+          else
+            raise RuntimeError, "Invalid metadata file: #{metadata_file} for cookbook: #{cookbook_version}"
+          end
+        end
+
+        @metadata
+
+        # Rescue errors so that users can upload cookbooks via `knife cookbook
+        # upload` even if some cookbooks in their chef-repo have errors in
+        # their metadata. We only rescue StandardError because you have to be
+        # doing something *really* terrible to raise an exception that inherits
+        # directly from Exception in your metadata.rb file.
+      rescue StandardError => e
+        @metadata_error = e
+        @metadata
+      end
+
+      def raise_metadata_error!
+        raise @metadata_error unless @metadata_error.nil?
+        # Metadata won't be valid if the cookbook is empty. If the cookbook is
+        # actually empty, a metadata error here would be misleading, so don't
+        # raise it (if called by #load!, a different error is raised).
+        if !empty? && !metadata.valid?
+          message = "Cookbook loaded at path(s) [#{@cookbook_paths.join(', ')}] has invalid metadata: #{metadata.errors.join('; ')}"
+          raise Exceptions::MetadataNotValid, message
+        end
+        false
+      end
+
+      def empty?
+        cookbook_settings.values.all? { |files_hash| files_hash.empty? } && metadata_filenames.size == 0
+      end
+
+      def merge!(other_cookbook_loader)
+        other_cookbook_settings = other_cookbook_loader.cookbook_settings
+        cookbook_settings.each do |file_type, file_list|
+          file_list.merge!(other_cookbook_settings[file_type])
+        end
+        metadata_filenames.concat(other_cookbook_loader.metadata_filenames)
+        @cookbook_paths += other_cookbook_loader.cookbook_paths
+        @frozen = true if other_cookbook_loader.frozen
+        @metadata = nil # reset metadata so it gets reloaded and all metadata files applied.
+        self
+      end
+
+      def chefignore
+        @chefignore ||= Chefignore.new(File.basename(cookbook_path))
+      end
+
+      def load_root_files
+        Dir.glob(File.join(Chef::Util::PathHelper.escape_glob(cookbook_path), '*'), File::FNM_DOTMATCH).each do |file|
+          file = Chef::Util::PathHelper.cleanpath(file)
+          next if File.directory?(file)
+          next if File.basename(file) == UPLOADED_COOKBOOK_VERSION_FILE
+          name = Chef::Util::PathHelper.relative_path_from(@cookbook_path, file)
+          cookbook_settings[:root_filenames][name] = file
+        end
+      end
+
+      def load_recursively_as(category, category_dir, glob)
+        file_spec = File.join(Chef::Util::PathHelper.escape_glob(cookbook_path, category_dir), '**', glob)
+        Dir.glob(file_spec, File::FNM_DOTMATCH).each do |file|
+          file = Chef::Util::PathHelper.cleanpath(file)
+          next if File.directory?(file)
+          name = Chef::Util::PathHelper.relative_path_from(@cookbook_path, file)
+          cookbook_settings[category][name] = file
+        end
+      end
+
+      def load_as(category, *path_glob)
+        Dir[File.join(Chef::Util::PathHelper.escape_glob(cookbook_path), *path_glob)].each do |file|
+          file = Chef::Util::PathHelper.cleanpath(file)
+          name = Chef::Util::PathHelper.relative_path_from(@cookbook_path, file)
+          cookbook_settings[category][name] = file
+        end
+      end
+
+      def remove_ignored_files
+        cookbook_settings.each_value do |file_list|
+          file_list.reject! do |relative_path, full_path|
+            chefignore.ignored?(relative_path)
+          end
+        end
+      end
+
+      def apply_ruby_metadata(file)
+        begin
+          @metadata.from_file(file)
+        rescue Chef::Exceptions::JSON::ParseError
+          Chef::Log.error("Error evaluating metadata.rb for #@inferred_cookbook_name in " + file)
+          raise
+        end
+      end
+
+      def apply_json_metadata(file)
+        begin
+          @metadata.from_json(IO.read(file))
+        rescue Chef::Exceptions::JSON::ParseError
+          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@inferred_cookbook_name in " + file)
+          raise
+        end
+      end
+
+      def apply_json_cookbook_version_metadata(file)
+        begin
+          data = Chef::JSONCompat.parse(IO.read(file))
+          @metadata.from_hash(data['metadata'])
+          # the JSON cookbok metadata file is only used by chef-zero.
+          # The Chef Server API currently does not enforce that the metadata
+          # have a `name` field, but that will cause an error when attempting
+          # to load the cookbook. To keep compatibility, we fake it by setting
+          # the metadata name from the cookbook version object's name.
+          #
+          # This behavior can be removed if/when Chef Server enforces that the
+          # metadata contains a name key.
+          @metadata.name(data['cookbook_name']) unless data['metadata'].key?('name')
+        rescue Chef::Exceptions::JSON::ParseError
+          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@inferred_cookbook_name in " + file)
+          raise
+        end
+      end
+
+      def set_frozen
+        if uploaded_cookbook_version_file
+          begin
+            data = Chef::JSONCompat.parse(IO.read(uploaded_cookbook_version_file))
+            @frozen = data['frozen?']
+          rescue Chef::Exceptions::JSON::ParseError
+            Chef::Log.error("Couldn't parse cookbook metadata JSON for #@inferred_cookbook_name in #{uploaded_cookbook_version_file}")
+            raise
+          end
+        end
+      end
+    end
+  end
+end