microwave 0.1006.33 → 1.0.0

data/lib/chef/cookbook_version_selector.rb

@@ -1,149 +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.
-
-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
-
-  end
-end

data/lib/chef/environment.rb

@@ -1,231 +0,0 @@
-#
-# Author:: Stephen Delano (<stephen@opscode.com>)
-# Author:: Seth Falcon (<seth@opscode.com>)
-# Author:: John Keiser (<jkeiser@ospcode.com>)
-# Copyright:: Copyright 2010-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 'chef/config'
-require 'chef/mash'
-require 'chef/mixin/params_validate'
-require 'chef/mixin/from_file'
-require 'chef/version_constraint'
-
-class Chef
-  class Environment
-
-    DEFAULT = "default"
-
-    include Chef::Mixin::ParamsValidate
-    include Chef::Mixin::FromFile
-
-    COMBINED_COOKBOOK_CONSTRAINT = /(.+)(?:[\s]+)((?:#{Chef::VersionConstraint::OPS.join('|')})(?:[\s]+).+)$/.freeze
-
-    def initialize()
-      @name = ''
-      @description = ''
-      @default_attributes = Mash.new
-      @override_attributes = Mash.new
-      @cookbook_versions = Hash.new
-    end
-
-    def name(arg=nil)
-      set_or_return(
-        :name,
-        arg,
-        { :regex => /^[\-[:alnum:]_]+$/, :kind_of => String }
-      )
-    end
-
-    def description(arg=nil)
-      set_or_return(
-        :description,
-        arg,
-        :kind_of => String
-      )
-    end
-
-    def default_attributes(arg=nil)
-      set_or_return(
-        :default_attributes,
-        arg,
-        :kind_of => Hash
-      )
-    end
-
-    def override_attributes(arg=nil)
-      set_or_return(
-        :override_attributes,
-        arg,
-        :kind_of => Hash
-      )
-    end
-
-    def cookbook_versions(arg=nil)
-      set_or_return(
-        :cookbook_versions,
-        arg,
-        {
-          :kind_of => Hash,
-          :callbacks => {
-            "should be a valid set of cookbook version requirements" => lambda { |cv| Chef::Environment.validate_cookbook_versions(cv) }
-          }
-        }
-      )
-    end
-
-    def cookbook(cookbook, version)
-      validate({
-        :version => version
-      },{
-        :version => {
-          :callbacks => { "should be a valid version requirement" => lambda { |v| Chef::Environment.validate_cookbook_version(v) } }
-        }
-      })
-      @cookbook_versions[cookbook] = version
-    end
-
-    def to_hash
-      result = {
-        "name" => @name,
-        "description" => @description,
-        "cookbook_versions" =>  @cookbook_versions,
-        "json_class" => self.class.name,
-        "chef_type" => "environment",
-        "default_attributes" => @default_attributes,
-        "override_attributes" => @override_attributes
-      }
-      result
-    end
-
-    def to_json(*a)
-      to_hash.to_json(*a)
-    end
-
-    def update_from!(o)
-      description(o.description)
-      cookbook_versions(o.cookbook_versions)
-      default_attributes(o.default_attributes)
-      override_attributes(o.override_attributes)
-      self
-    end
-
-
-    def update_attributes_from_params(params)
-      unless params[:default_attributes].nil? || params[:default_attributes].size == 0
-        default_attributes(Chef::JSONCompat.from_json(params[:default_attributes]))
-      end
-      unless params[:override_attributes].nil? || params[:override_attributes].size == 0
-        override_attributes(Chef::JSONCompat.from_json(params[:override_attributes]))
-      end
-    end
-
-    def update_from_params(params)
-      # reset because everything we need will be in the params, this is necessary because certain constraints
-      # may have been removed in the params and need to be removed from cookbook_versions as well.
-      bkup_cb_versions = cookbook_versions
-      cookbook_versions(Hash.new)
-      valid = true
-
-      begin
-        name(params[:name])
-      rescue Chef::Exceptions::ValidationFailed => e
-        invalid_fields[:name] = e.message
-        valid = false
-      end
-      description(params[:description])
-
-      unless params[:cookbook_version].nil?
-        params[:cookbook_version].each do |index, cookbook_constraint_spec|
-          unless (cookbook_constraint_spec.nil? || cookbook_constraint_spec.size == 0)
-            valid = valid && update_cookbook_constraint_from_param(index, cookbook_constraint_spec)
-          end
-        end
-      end
-
-      update_attributes_from_params(params)
-
-      valid = validate_required_attrs_present && valid
-      cookbook_versions(bkup_cb_versions) unless valid # restore the old cookbook_versions if valid is false
-      valid
-    end
-
-    def update_cookbook_constraint_from_param(index, cookbook_constraint_spec)
-      valid = true
-      md = cookbook_constraint_spec.match(COMBINED_COOKBOOK_CONSTRAINT)
-      if md.nil? || md[2].nil?
-        valid = false
-        add_cookbook_constraint_error(index, cookbook_constraint_spec)
-      elsif self.class.validate_cookbook_version(md[2])
-        cookbook_versions[md[1]] = md[2]
-      else
-        valid = false
-        add_cookbook_constraint_error(index, cookbook_constraint_spec)
-      end
-      valid
-    end
-
-    def add_cookbook_constraint_error(index, cookbook_constraint_spec)
-      invalid_fields[:cookbook_version] ||= {}
-      invalid_fields[:cookbook_version][index] = "#{cookbook_constraint_spec} is not a valid cookbook constraint"
-    end
-
-    def invalid_fields
-      @invalid_fields ||= {}
-    end
-
-    def validate_required_attrs_present
-      if name.nil? || name.size == 0
-        invalid_fields[:name] ||= "name cannot be empty"
-        false
-      else
-        true
-      end
-    end
-
-
-    def self.json_create(o)
-      environment = new
-      environment.name(o["name"])
-      environment.description(o["description"])
-      environment.cookbook_versions(o["cookbook_versions"])
-      environment.default_attributes(o["default_attributes"])
-      environment.override_attributes(o["override_attributes"])
-      environment
-    end
-
-    def to_s
-      @name
-    end
-
-    def self.validate_cookbook_versions(cv)
-      return false unless cv.kind_of?(Hash)
-      cv.each do |cookbook, version|
-        return false unless Chef::Environment.validate_cookbook_version(version)
-      end
-      true
-    end
-
-    def self.validate_cookbook_version(version)
-      begin
-        Chef::VersionConstraint.new version
-        true
-      rescue ArgumentError
-        false
-      end
-    end
-  end
-end

data/lib/chef/exceptions.rb

@@ -1,150 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Seth Falcon (<seth@opscode.com>)
-# Copyright:: Copyright 2008-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.
-
-class Chef
-  # == Chef::Exceptions
-  # Chef's custom exceptions are all contained within the Chef::Exceptions
-  # namespace.
-  class Exceptions
-    class Application < RuntimeError; end
-    class Cron < RuntimeError; end
-    class Env < RuntimeError; end
-    class Exec < RuntimeError; end
-    class ErlCall < RuntimeError; end
-    class FileNotFound < RuntimeError; end
-    class Package < RuntimeError; end
-    class Service < RuntimeError; end
-    class Route < RuntimeError; end
-    class SearchIndex < RuntimeError; end
-    class Override < RuntimeError; end
-    class UnsupportedAction < RuntimeError; end
-    class MissingLibrary < RuntimeError; end
-    class MissingRole < RuntimeError; end
-    class CannotDetermineNodeName < RuntimeError; end
-    class User < RuntimeError; end
-    class Group < RuntimeError; end
-    class Link < RuntimeError; end
-    class Mount < RuntimeError; end
-    class PrivateKeyMissing < RuntimeError; end
-    class CannotWritePrivateKey < RuntimeError; end
-    class RoleNotFound < RuntimeError; end
-    class ValidationFailed < ArgumentError; end
-    class InvalidPrivateKey < ArgumentError; end
-    class ConfigurationError < ArgumentError; end
-    class RedirectLimitExceeded < RuntimeError; end
-    class AmbiguousRunlistSpecification < ArgumentError; end
-    class CookbookNotFound < RuntimeError; end
-    # Cookbook loader used to raise an argument error when cookbook not found.
-    # for back compat, need to raise an error that inherits from ArgumentError
-    class CookbookNotFoundInRepo < ArgumentError; end
-    class AttributeNotFound < RuntimeError; end
-    class InvalidCommandOption < RuntimeError; end
-    class CommandTimeout < RuntimeError; end
-    class ShellCommandFailed < RuntimeError; end
-    class RequestedUIDUnavailable < RuntimeError; end
-    class InvalidHomeDirectory < ArgumentError; end
-    class DsclCommandFailed < RuntimeError; end
-    class UserIDNotFound < ArgumentError; end
-    class GroupIDNotFound < ArgumentError; end
-    class InvalidResourceReference < RuntimeError; end
-    class ResourceNotFound < RuntimeError; end
-    class InvalidResourceSpecification < ArgumentError; end
-    class SolrConnectionError < RuntimeError; end
-    class IllegalChecksumRevert < RuntimeError; end
-    class CookbookVersionNameMismatch < ArgumentError; end
-    class MissingParentDirectory < RuntimeError; end
-    class UnresolvableGitReference < RuntimeError; end
-    class InvalidEnvironmentRunListSpecification < ArgumentError; end
-    class EnclosingDirectoryDoesNotExist < ArgumentError; end
-
-    class ObsoleteDependencySyntax < ArgumentError; end
-
-    # A different version of a cookbook was added to a
-    # VersionedRecipeList than the one already there.
-    class CookbookVersionConflict < ArgumentError ; end
-
-    # does not follow X.Y.Z format. ArgumentError?
-    class InvalidCookbookVersion < ArgumentError; end
-
-    # version constraint should be a string or array, or it doesn't
-    # match OP VERSION. ArgumentError?
-    class InvalidVersionConstraint < ArgumentError; end
-
-    class CookbookVersionSelection
-
-      # Compound exception: In run_list expansion and resolution,
-      # run_list items referred to cookbooks that don't exist and/or
-      # have no versions available.
-      class InvalidRunListItems < StandardError
-        attr_reader :non_existent_cookbooks
-        attr_reader :cookbooks_with_no_matching_versions
-
-        def initialize(message, non_existent_cookbooks, cookbooks_with_no_matching_versions)
-          super(message)
-
-          @non_existent_cookbooks = non_existent_cookbooks
-          @cookbooks_with_no_matching_versions = cookbooks_with_no_matching_versions
-        end
-
-        def to_json(*a)
-          result = {
-            "message" => message,
-            "non_existent_cookbooks" => non_existent_cookbooks,
-            "cookbooks_with_no_versions" => cookbooks_with_no_matching_versions
-          }
-          result.to_json(*a)
-        end
-      end
-
-      # In run_list expansion and resolution, a constraint was
-      # unsatisfiable.
-      #
-      # This exception may not be the complete error report. If you
-      # resolve the misconfiguration represented by this exception and
-      # re-solve, you may get another exception
-      class UnsatisfiableRunListItem < StandardError
-        attr_reader :run_list_item
-        attr_reader :non_existent_cookbooks, :most_constrained_cookbooks
-
-        # most_constrained_cookbooks: if I were to remove constraints
-        # regarding these cookbooks, I would get a solution or move on
-        # to the next error (deeper in the graph). An item in this list
-        # may be unsatisfiable, but when resolved may also reveal
-        # further unsatisfiable constraints; this condition would not be
-        # reported.
-        def initialize(message, run_list_item, non_existent_cookbooks, most_constrained_cookbooks)
-          super(message)
-
-          @run_list_item = run_list_item
-          @non_existent_cookbooks = non_existent_cookbooks
-          @most_constrained_cookbooks = most_constrained_cookbooks
-        end
-
-        def to_json(*a)
-          result = {
-            "message" => message,
-            "unsatisfiable_run_list_item" => run_list_item,
-            "non_existent_cookbooks" => non_existent_cookbooks,
-            "most_constrained_cookbooks" => most_constrained_cookbooks
-          }
-          result.to_json(*a)
-        end
-      end
-    end
-  end
-end