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

data/lib/chef/checksum_cache.rb

@@ -1,190 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
-# Copyright:: Copyright (c) 2009 Daniel DeLeo
-# 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 'set'
-require 'fileutils'
-require 'chef/log'
-require 'chef/config'
-require 'chef/client'
-require 'chef/mixin/convert_to_class_name'
-require 'singleton'
-require 'moneta'
-
-class Chef
-  class ChecksumCache
-    include Chef::Mixin::ConvertToClassName
-    include ::Singleton
-
-    attr_reader :moneta
-
-    def initialize(*args)
-      self.reset!(*args)
-    end
-
-    def reset!(backend=nil, options=nil)
-      backend ||= Chef::Config[:cache_type]
-      options ||= Chef::Config[:cache_options]
-
-      begin
-        require "moneta/#{convert_to_snake_case(backend, 'Moneta')}"
-        require 'chef/monkey_patches/moneta'
-      rescue LoadError => e
-        Chef::Log.fatal("Could not load Moneta back end #{backend.inspect}")
-        raise e
-      end
-
-      @moneta = Moneta.const_get(backend).new(options)
-    end
-
-    def self.reset_cache_validity
-      @valid_cached_checksums = nil
-    end
-
-    Chef::Client.when_run_starts do |run_status|
-      reset_cache_validity
-    end
-
-    def self.valid_cached_checksums
-      @valid_cached_checksums ||= Set.new
-    end
-
-    def self.validate_checksum(checksum_key)
-      valid_cached_checksums << checksum_key
-    end
-
-    def self.all_cached_checksums
-      all_checksums_with_filenames = {}
-
-      Dir[File.join(Chef::Config[:cache_options][:path], '*')].each do |cksum_file|
-        all_checksums_with_filenames[File.basename(cksum_file)] = cksum_file
-      end
-      all_checksums_with_filenames
-    end
-
-    def self.cleanup_checksum_cache
-      Chef::Log.debug("Cleaning the checksum cache")
-      if (Chef::Config[:cache_type].to_s == "BasicFile")
-        all_cached_checksums.each do |cache_key, cksum_cache_file|
-          unless valid_cached_checksums.include?(cache_key)
-            remove_unused_checksum(cksum_cache_file)
-          end
-        end
-      end
-    end
-
-    Chef::Client.when_run_completes_successfully do |run_status|
-      cleanup_checksum_cache
-    end
-
-    def self.remove_unused_checksum(checksum_file)
-      Chef::Log.debug("Removing unused checksum cache file #{checksum_file}")
-      FileUtils.rm(checksum_file)
-    end
-
-    def self.checksum_for_file(*args)
-      instance.checksum_for_file(*args)
-    end
-
-    def validate_checksum(*args)
-      self.class.validate_checksum(*args)
-    end
-
-    def checksum_for_file(file, key=nil)
-      key ||= generate_key(file)
-      fstat = File.stat(file)
-      lookup_checksum(key, fstat) || generate_checksum(key, file, fstat)
-    end
-
-    def lookup_checksum(key, fstat)
-      cached = fetch(key)
-      if cached && file_unchanged?(cached, fstat)
-        validate_checksum(key)
-        cached["checksum"]
-      else
-        nil
-      end
-    end
-
-    def generate_checksum(key, file, fstat)
-      checksum = checksum_file(file, Digest::SHA256.new)
-      moneta.store(key, {"mtime" => fstat.mtime.to_f, "checksum" => checksum})
-      validate_checksum(key)
-      checksum
-    end
-
-    def generate_key(file, group="chef")
-      "#{group}-file-#{file.gsub(/(#{File::SEPARATOR}|\.)/, '-')}"
-    end
-
-    def self.generate_md5_checksum_for_file(*args)
-      instance.generate_md5_checksum_for_file(*args)
-    end
-
-    def generate_md5_checksum_for_file(file)
-      checksum_file(file, Digest::MD5.new)
-    end
-
-    def generate_md5_checksum(io)
-      checksum_io(io, Digest::MD5.new)
-    end
-
-    private
-
-    def fetch(key)
-      @moneta.fetch(key)
-    rescue ArgumentError, TypeError => e
-      Log.warn "Error loading cached checksum for key #{key.inspect}"
-      Log.warn(e)
-      repair_checksum_cache
-      nil
-    end
-
-    def repair_checksum_cache
-      Chef::Log.info("Removing invalid checksum cache files")
-      Dir["#{Chef::Config[:cache_options][:path]}/*"].each do |file_path|
-        File.unlink(file_path) unless File.size?(file_path)
-      end
-    end
-
-    def file_unchanged?(cached, fstat)
-      cached["mtime"].to_f == fstat.mtime.to_f
-    end
-
-    def checksum_file(file, digest)
-      File.open(file, 'rb') { |f| checksum_io(f, digest) }
-    end
-
-    def checksum_io(io, digest)
-      while chunk = io.read(1024 * 8)
-        digest.update(chunk)
-      end
-      digest.hexdigest
-    end
-
-  end
-end
-
-module Moneta
-  module Defaults
-    def default
-      nil
-    end
-  end
-end

data/lib/chef/cookbook_version_selector.rb

@@ -1,168 +0,0 @@
-#
-# Author:: Tim Hinderliter (<tim@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.
-
-require 'dep_selector'
-
-class Chef
-  module CookbookVersionSelector
-    # This method replaces verbiage from DepSelector messages with
-    # Chef-domain-specific verbiage, such as replacing package with
-    # cookbook.
-    #
-    # TODO [cw, 2011/2/25]: this is a near-term hack. In the long run,
-    # we'll do this better.
-    def self.filter_dep_selector_message(message)
-      m = message
-      m.gsub!("Package", "Cookbook")
-      m.gsub!("package", "cookbook")
-      m.gsub!("Solution constraint", "Run list item")
-      m.gsub!("solution constraint", "run list item")
-      m
-    end
-
-    # all_cookbooks - a hash mapping cookbook names to an array of
-    # available CookbookVersions.
-    #
-    # Creates a DependencyGraph from CookbookVersion objects
-    def self.create_dependency_graph_from_cookbooks(all_cookbooks)
-      dep_graph = DepSelector::DependencyGraph.new
-
-      all_cookbooks.each do |cb_name, cb_versions|
-        cb_versions.each do |cb_version|
-          cb_version_deps = cb_version.metadata.dependencies
-          # TODO [cw. 2011/2/10]: CookbookVersion#version returns a
-          # String even though we're storing as a DepSelector::Version
-          # object underneath. This should be changed so that we
-          # return the object and handle proper serialization and
-          # de-serialization. For now, I'm just going to create a
-          # Version object from the String representation.
-          pv = dep_graph.package(cb_name).add_version(Chef::Version.new(cb_version.version))
-          cb_version_deps.each_pair do |dep_name, constraint_str|
-            # if the dependency is specified as cookbook::recipe,
-            # extract the cookbook component
-            dep_cb_name = dep_name.split("::").first
-            constraint = Chef::VersionConstraint.new(constraint_str)
-            pv.dependencies << DepSelector::Dependency.new(dep_graph.package(dep_cb_name), constraint)
-          end
-        end
-      end
-
-      dep_graph
-    end
-
-    # Return a hash mapping cookbook names to a CookbookVersion
-    # object. If there is no solution that satisfies the constraints,
-    # the first run list item that caused unsatisfiability is
-    # returned.
-    #
-    # This is the final version-resolved list of cookbooks for the
-    # RunList.
-    #
-    # all_cookbooks - a hash mapping cookbook names to an array of
-    # available CookbookVersions.
-    #
-    # recipe_constraints - an array of hashes describing the expanded
-    # run list.  Each element is a hash containing keys :name and
-    # :version_constraint. The :name component is either the
-    # fully-qualified recipe name (e.g. "cookbook1::non_default_recipe")
-    # or just a cookbook name, indicating the default recipe is to be
-    # run (e.g. "cookbook1").
-    def self.constrain(all_cookbooks, recipe_constraints)
-      dep_graph = create_dependency_graph_from_cookbooks(all_cookbooks)
-
-      # extract cookbook names from (possibly) fully-qualified recipe names
-      cookbook_constraints = recipe_constraints.map do |recipe_spec|
-        cookbook_name = (recipe_spec[:name][/^(.+)::/, 1] || recipe_spec[:name])
-        DepSelector::SolutionConstraint.new(dep_graph.package(cookbook_name),
-                                            recipe_spec[:version_constraint])
-      end
-
-      # Pass in the list of all available cookbooks (packages) so that
-      # DepSelector can distinguish between "no version available for
-      # cookbook X" and "no such cookbook X" when an environment
-      # filters out all versions for a given cookbook.
-      all_packages = all_cookbooks.inject([]) do |acc, (cookbook_name, cookbook_versions)|
-        acc << dep_graph.package(cookbook_name)
-        acc
-      end
-
-      # find a valid assignment of CoookbookVersions. If no valid
-      # assignment exists, indicate which run_list_item causes the
-      # unsatisfiability and try to hint at what might be wrong.
-      soln =
-        begin
-          DepSelector::Selector.new(dep_graph).find_solution(cookbook_constraints, all_packages)
-        rescue DepSelector::Exceptions::InvalidSolutionConstraints => e
-          non_existent_cookbooks = e.non_existent_packages.map {|constraint| constraint.package.name}
-          cookbooks_with_no_matching_versions = e.constrained_to_no_versions.map {|constraint| constraint.package.name}
-
-          # Spend a whole lot of effort for pluralizing and
-          # prettifying the message.
-          message = ""
-          if non_existent_cookbooks.length > 0
-            message += "no such " + (non_existent_cookbooks.length > 1 ? "cookbooks" : "cookbook")
-            message += " #{non_existent_cookbooks.join(", ")}"
-          end
-
-          if cookbooks_with_no_matching_versions.length > 0
-            if message.length > 0
-              message += "; "
-            end
-
-            message += "no versions match the constraints on " + (cookbooks_with_no_matching_versions.length > 1 ? "cookbooks" : "cookbook")
-            message += " #{cookbooks_with_no_matching_versions.join(", ")}"
-          end
-
-          message = "Run list contains invalid items: #{message}."
-
-          raise Chef::Exceptions::CookbookVersionSelection::InvalidRunListItems.new(message, non_existent_cookbooks, cookbooks_with_no_matching_versions)
-        rescue DepSelector::Exceptions::NoSolutionExists => e
-          raise Chef::Exceptions::CookbookVersionSelection::UnsatisfiableRunListItem.new(filter_dep_selector_message(e.message), e.unsatisfiable_solution_constraint, e.disabled_non_existent_packages, e.disabled_most_constrained_packages)
-        end
-
-
-      # map assignment back to CookbookVersion objects
-      selected_cookbooks = {}
-      soln.each_pair do |cb_name, cb_version|
-        # TODO [cw, 2011/2/10]: related to the TODO in
-        # create_dependency_graph_from_cookbooks, cbv.version
-        # currently returns a String, so we must compare to
-        # cb_version.to_s, since it's a for-real Version object.
-        selected_cookbooks[cb_name] = all_cookbooks[cb_name].find{|cbv| cbv.version == cb_version.to_s}
-      end
-      selected_cookbooks
-    end
-
-    # Expands the run_list, constrained to the environment's CookbookVersion
-    # constraints.
-    #
-    # Returns:
-    #   Hash of: name to CookbookVersion
-    def self.expand_to_cookbook_versions(run_list, environment, couchdb=nil)
-      # expand any roles in this run_list.
-      expanded_run_list = run_list.expand(environment, 'couchdb', :couchdb => couchdb).recipes.with_version_constraints
-
-      cookbooks_for_environment = Chef::Environment.cdb_minimal_filtered_versions(environment, couchdb)
-      cookbook_collection = constrain(cookbooks_for_environment, expanded_run_list)
-      full_cookbooks = Chef::MinimalCookbookVersion.load_full_versions_of(cookbook_collection.values, couchdb)
-      full_cookbooks.inject({}) do |cb_map, cookbook_version|
-        cb_map[cookbook_version.name] = cookbook_version
-        cb_map
-      end
-    end
-  end
-end

data/lib/chef/couchdb.rb

@@ -1,246 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Brown (<cb@opscode.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/mixin/params_validate'
-require 'chef/config'
-require 'chef/rest'
-require 'chef/log'
-require 'digest/sha2'
-require 'chef/json_compat'
-
-# We want to fail on create if uuidtools isn't installed
-begin
-  require 'uuidtools'
-rescue LoadError
-end
-
-class Chef
-  class CouchDB
-    include Chef::Mixin::ParamsValidate
-
-    def initialize(url=nil, db=Chef::Config[:couchdb_database])
-      url ||= Chef::Config[:couchdb_url]
-      @db = db
-      @rest = Chef::REST.new(url, nil, nil)
-    end
-
-    def couchdb_database(args=nil)
-      @db = args || @db
-    end
-
-    def create_id_map
-      create_design_document(
-        "id_map",
-        {
-          "version" => 1,
-          "language" => "javascript",
-          "views" => {
-            "name_to_id" => {
-              "map" => <<-EOJS
-                function(doc) {
-                  emit([ doc.chef_type, doc.name], doc._id);
-                }
-              EOJS
-            },
-            "id_to_name" => {
-              "map" => <<-EOJS
-                function(doc) {
-                  emit(doc._id, [ doc.chef_type, doc.name ]);
-                }
-              EOJS
-            }
-          }
-        }
-      )
-    end
-
-    def create_db(check_for_existing=true)
-      @database_list = @rest.get_rest("_all_dbs")
-      if !check_for_existing || !@database_list.any? { |db| db == couchdb_database }
-        response = @rest.put_rest(couchdb_database, Hash.new)
-      end
-      couchdb_database
-    end
-
-    def create_design_document(name, data)
-      to_update = true
-      begin
-        old_doc = @rest.get_rest("#{couchdb_database}/_design/#{name}")
-        if data["version"] != old_doc["version"]
-          data["_rev"] = old_doc["_rev"]
-          Chef::Log.debug("Updating #{name} views")
-        else
-          to_update = false
-        end
-      rescue
-        Chef::Log.debug("Creating #{name} views for the first time because: #{$!}")
-      end
-      if to_update
-        @rest.put_rest("#{couchdb_database}/_design%2F#{name}", data)
-      end
-      true
-    end
-
-    # Save the object to Couch. Add to index if the object supports it.
-    def store(obj_type, name, object)
-      validate(
-        {
-          :obj_type => obj_type,
-          :name => name,
-          :object => object,
-        },
-        {
-          :object => { :respond_to => :to_json },
-        }
-      )
-      rows = get_view("id_map", "name_to_id", :key => [ obj_type, name ])["rows"]
-      uuid = rows.empty? ? UUIDTools::UUID.random_create.to_s : rows.first.fetch("id")
-
-      db_put_response = @rest.put_rest("#{couchdb_database}/#{uuid}", object)
-
-      if object.respond_to?(:add_to_index)
-        Chef::Log.info("Sending #{obj_type}(#{uuid}) to the index queue for addition.")
-        object.add_to_index(:database => couchdb_database, :id => uuid, :type => obj_type)
-      end
-
-      db_put_response
-    end
-
-    def load(obj_type, name)
-      validate(
-        {
-          :obj_type => obj_type,
-          :name => name,
-        },
-        {
-          :obj_type => { :kind_of => String },
-          :name => { :kind_of => String },
-        }
-               )
-      doc = find_by_name(obj_type, name)
-      doc.couchdb = self if doc.respond_to?(:couchdb)
-      doc
-    end
-
-    def delete(obj_type, name, rev=nil)
-      validate(
-        {
-          :obj_type => obj_type,
-          :name => name,
-        },
-        {
-          :obj_type => { :kind_of => String },
-          :name => { :kind_of => String },
-        }
-      )
-      del_id = nil
-      object, uuid = find_by_name(obj_type, name, true)
-      unless rev
-        if object.respond_to?(:couchdb_rev)
-          rev = object.couchdb_rev
-        else
-          rev = object['_rev']
-        end
-      end
-      response = @rest.delete_rest("#{couchdb_database}/#{uuid}?rev=#{rev}")
-      response.couchdb = self if response.respond_to?(:couchdb=)
-
-      if object.respond_to?(:delete_from_index)
-        Chef::Log.info("Sending #{obj_type}(#{uuid}) to the index queue for deletion..")
-        object.delete_from_index(:database => couchdb_database, :id => uuid, :type => obj_type)
-      end
-
-      response
-    end
-
-    def list(view, inflate=false)
-      validate(
-        {
-          :view => view,
-        },
-        {
-          :view => { :kind_of => String }
-        }
-      )
-      if inflate
-        r = @rest.get_rest(view_uri(view, "all"))
-        r["rows"].each { |i| i["value"].couchdb = self if i["value"].respond_to?(:couchdb=) }
-        r
-      else
-        r = @rest.get_rest(view_uri(view, "all_id"))
-      end
-      r
-    end
-
-    def has_key?(obj_type, name)
-      validate(
-        {
-          :obj_type => obj_type,
-          :name => name,
-        },
-        {
-          :obj_type => { :kind_of => String },
-          :name => { :kind_of => String },
-        }
-      )
-      begin
-        find_by_name(obj_type, name)
-        true
-      rescue
-        false
-      end
-    end
-
-    def find_by_name(obj_type, name, with_id=false)
-      r = get_view("id_map", "name_to_id", :key => [ obj_type, name ], :include_docs => true)
-      if r["rows"].length == 0
-        raise Chef::Exceptions::CouchDBNotFound, "Cannot find #{obj_type} #{name} in CouchDB!"
-      end
-      if with_id
-        [ r["rows"][0]["doc"], r["rows"][0]["id"] ]
-      else
-        r["rows"][0]["doc"]
-      end
-    end
-
-    def get_view(design, view, options={})
-      view_string = view_uri(design, view)
-      view_string << "?" if options.length != 0
-      view_string << options.map { |k,v| "#{k}=#{URI.escape(v.to_json)}"}.join('&')
-      @rest.get_rest(view_string)
-    end
-
-    def bulk_get(*to_fetch)
-      response = @rest.post_rest("#{couchdb_database}/_all_docs?include_docs=true", { "keys" => to_fetch.flatten })
-      response["rows"].collect { |r| r["doc"] }
-    end
-
-    def view_uri(design, view)
-      "#{couchdb_database}/_design/#{design}/_view/#{view}"
-    end
-
-    def server_stats
-      @rest.get_rest('/')
-    end
-
-    def db_stats
-      @rest.get_rest("/#{@db}")
-    end
-
-  end
-end