chef 0.9.18 → 0.10.0.beta.0

data/lib/chef/cookbook/file_system_file_vendor.rb

@@ -7,9 +7,9 @@
 # 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.
@@ -30,25 +30,27 @@ class Chef
     # locations, since in the chef-client case, that information is
     # non-sensical.
     class FileSystemFileVendor < FileVendor
-      
-      def initialize(manifest)
+
+      def initialize(manifest, *repo_paths)
         @cookbook_name = manifest[:cookbook_name]
+        @repo_paths = repo_paths.flatten
+        raise ArgumentError, "You must specify at least one repo path" if @repo_paths.empty?
       end
-      
+
       # Implements abstract base's requirement. It looks in the
       # Chef::Config.cookbook_path file hierarchy for the requested
       # file.
       def get_filename(filename)
-        location = Array(Chef::Config.cookbook_path).inject(nil) do |memo, basepath|
+        location = @repo_paths.inject(nil) do |memo, basepath|
           candidate_location = File.join(basepath, @cookbook_name, filename)
           memo = candidate_location if File.exist?(candidate_location)
           memo
         end
         raise "File #{filename} does not exist for cookbook #{@cookbook_name}" unless location
-        
+
         location
       end
-      
+
     end
   end
 end

data/lib/chef/cookbook/metadata.rb

@@ -1,15 +1,16 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: AJ Christensen (<aj@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# 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.
@@ -21,7 +22,8 @@ require 'chef/mixin/from_file'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/check_helper'
 require 'chef/log'
-require 'chef/cookbook/metadata/version'
+require 'chef/version_class'
+require 'chef/version_constraint'
 
 class Chef
   class Cookbook
@@ -34,12 +36,19 @@ class Chef
                             :maintainer_email, :license, :platforms, :dependencies,
                             :recommendations, :suggestions, :conflicting, :providing,
                             :replacing, :attributes, :groupings, :recipes, :version]
-    
+
+      VERSION_CONSTRAINTS = {:depends     => "dependencies",
+                             :recommends  => "recommendations",
+                             :suggests    => "suggestions",
+                             :conflicts   => "conflicting",
+                             :provides    => "providing",
+                             :replaces    => "replacing" }
+
       include Chef::Mixin::CheckHelper
       include Chef::Mixin::ParamsValidate
       include Chef::Mixin::FromFile
 
-      attr_reader   :cookbook, 
+      attr_reader   :cookbook,
                     :platforms,
                     :dependencies,
                     :recommendations,
@@ -53,7 +62,7 @@ class Chef
                     :version
 
       # Builds a new Chef::Cookbook::Metadata object.
-      # 
+      #
       # === Parameters
       # cookbook<String>:: An optional cookbook object
       # maintainer<String>:: An optional maintainer
@@ -64,7 +73,7 @@ class Chef
       # metadata<Chef::Cookbook::Metadata>
       def initialize(cookbook=nil, maintainer='Your Name', maintainer_email='youremail@example.com', license='Apache v2.0')
         @cookbook = cookbook
-        @name = cookbook ? cookbook.name : "" 
+        @name = cookbook ? cookbook.name : ""
         @long_description = ""
         self.maintainer(maintainer)
         self.maintainer_email(maintainer_email)
@@ -82,8 +91,8 @@ class Chef
         @recipes = Mash.new
         @version = Version.new "0.0.0"
         if cookbook
-          @recipes = cookbook.fully_qualified_recipe_names.inject({}) do |r, e| 
-            e = self.name if e =~ /::default$/ 
+          @recipes = cookbook.fully_qualified_recipe_names.inject({}) do |r, e|
+            e = self.name if e =~ /::default$/
             r[e] = ""
             self.provides e
             r
@@ -115,7 +124,7 @@ class Chef
       # Sets the maintainers email address, or returns it.
       #
       # === Parameters
-      # maintainer_email<String>:: The maintainers email address 
+      # maintainer_email<String>:: The maintainers email address
       #
       # === Returns
       # maintainer_email<String>:: Returns the current maintainer email.
@@ -133,7 +142,7 @@ class Chef
       # license<String>:: The current license.
       #
       # === Returns
-      # license<String>:: Returns the current license 
+      # license<String>:: Returns the current license
       def license(arg=nil)
         set_or_return(
           :license,
@@ -145,10 +154,10 @@ class Chef
       # Sets the current description, or returns it. Should be short - one line only!
       #
       # === Parameters
-      # description<String>:: The new description 
+      # description<String>:: The new description
       #
       # === Returns
-      # description<String>:: Returns the description 
+      # description<String>:: Returns the description
       def description(arg=nil)
         set_or_return(
           :description,
@@ -157,13 +166,13 @@ class Chef
         )
       end
 
-      # Sets the current long description, or returns it. Might come from a README, say. 
+      # Sets the current long description, or returns it. Might come from a README, say.
       #
       # === Parameters
       # long_description<String>:: The new long description
       #
       # === Returns
-      # long_description<String>:: Returns the long description 
+      # long_description<String>:: Returns the long description
       def long_description(arg=nil)
         set_or_return(
           :long_description,
@@ -179,10 +188,10 @@ class Chef
       # version<String>:: The curent version, as a string
       #
       # === Returns
-      # version<String>:: Returns the current version 
+      # version<String>:: Returns the current version
       def version(arg=nil)
         if arg
-          @version = Version.new(arg)
+          @version = Chef::Version.new(arg)
         end
 
         @version.to_s
@@ -191,10 +200,10 @@ class Chef
       # Sets the name of the cookbook, or returns it.
       #
       # === Parameters
-      # name<String>:: The curent cookbook name. 
+      # name<String>:: The curent cookbook name.
       #
       # === Returns
-      # name<String>:: Returns the current cookbook name. 
+      # name<String>:: Returns the current cookbook name.
       def name(arg=nil)
         set_or_return(
           :name,
@@ -203,121 +212,141 @@ class Chef
         )
       end
 
-      # Adds a supported platform, with version checking strings. 
+      # Adds a supported platform, with version checking strings.
       #
       # === Parameters
       # platform<String>,<Symbol>:: The platform (like :ubuntu or :mac_os_x)
-      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      # version<String>:: A version constraint of the form "OP VERSION",
+      # where OP is one of < <= = > >= ~> and VERSION has
+      # the form x.y.z or x.y.
       #
       # === Returns
-      # versions<Array>:: Returns the list of versions for the platform 
-      def supports(platform, *versions)
-        versions.each { |v| _check_version_expression(v) }
-        @platforms[platform] = versions
+      # versions<Array>:: Returns the list of versions for the platform
+      def supports(platform, *version_args)
+        version = new_args_format(:supports, platform, version_args)
+        validate_version_constraint(:supports, platform, version)
+        @platforms[platform] = version
         @platforms[platform]
       end
 
       # Adds a dependency on another cookbook, with version checking strings.
       #
       # === Parameters
-      # cookbook<String>:: The cookbook 
-      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      # cookbook<String>:: The cookbook
+      # version<String>:: A version constraint of the form "OP VERSION",
+      # where OP is one of < <= = > >= ~> and VERSION has
+      # the form x.y.z or x.y.
       #
       # === Returns
-      # versions<Array>:: Returns the list of versions for the platform 
-      def depends(cookbook, *versions)
-        versions.each { |v| _check_version_expression(v) }
-        @dependencies[cookbook] = versions
+      # versions<Array>:: Returns the list of versions for the platform
+      def depends(cookbook, *version_args)
+        version = new_args_format(:depends, cookbook, version_args)
+        validate_version_constraint(:depends, cookbook, version)
+        @dependencies[cookbook] = version
         @dependencies[cookbook]
       end
 
       # Adds a recommendation for another cookbook, with version checking strings.
       #
       # === Parameters
-      # cookbook<String>:: The cookbook 
-      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      # cookbook<String>:: The cookbook
+      # version<String>:: A version constraint of the form "OP VERSION",
+      # where OP is one of < <= = > >= ~> and VERSION has
+      # the form x.y.z or x.y.
       #
       # === Returns
-      # versions<Array>:: Returns the list of versions for the platform 
-      def recommends(cookbook, *versions)
-        versions.each { |v| _check_version_expression(v) }
-        @recommendations[cookbook] = versions
+      # versions<Array>:: Returns the list of versions for the platform
+      def recommends(cookbook, *version_args)
+        version = new_args_format(:recommends, cookbook,  version_args)
+        validate_version_constraint(:recommends, cookbook, version)
+        @recommendations[cookbook] = version
         @recommendations[cookbook]
       end
 
       # Adds a suggestion for another cookbook, with version checking strings.
       #
       # === Parameters
-      # cookbook<String>:: The cookbook 
-      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      # cookbook<String>:: The cookbook
+      # version<String>:: A version constraint of the form "OP VERSION",
+      # where OP is one of < <= = > >= ~> and VERSION has the
+      # formx.y.z or x.y.
       #
       # === Returns
-      # versions<Array>:: Returns the list of versions for the platform 
-      def suggests(cookbook, *versions)
-        versions.each { |v| _check_version_expression(v) }
-        @suggestions[cookbook] = versions
-        @suggestions[cookbook] 
+      # versions<Array>:: Returns the list of versions for the platform
+      def suggests(cookbook, *version_args)
+        version = new_args_format(:suggests, cookbook, version_args)
+        validate_version_constraint(:suggests, cookbook, version)
+        @suggestions[cookbook] = version
+        @suggestions[cookbook]
       end
 
       # Adds a conflict for another cookbook, with version checking strings.
       #
       # === Parameters
-      # cookbook<String>:: The cookbook 
-      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      # cookbook<String>:: The cookbook
+      # version<String>:: A version constraint of the form "OP VERSION",
+      # where OP is one of < <= = > >= ~> and VERSION has
+      # the form x.y.z or x.y.
       #
       # === Returns
-      # versions<Array>:: Returns the list of versions for the platform 
-      def conflicts(cookbook, *versions)
-        versions.each { |v| _check_version_expression(v) }
-        @conflicting[cookbook] = versions
-        @conflicting[cookbook] 
+      # versions<Array>:: Returns the list of versions for the platform
+      def conflicts(cookbook, *version_args)
+        version = new_args_format(:conflicts, cookbook, version_args)
+        validate_version_constraint(:conflicts, cookbook, version)
+        @conflicting[cookbook] = version
+        @conflicting[cookbook]
       end
 
-      # Adds a recipe, definition, or resource provided by this cookbook. 
+      # Adds a recipe, definition, or resource provided by this cookbook.
       #
       # Recipes are specified as normal
       # Definitions are followed by (), and can include :params for prototyping
       # Resources are the stringified version (service[apache2])
       #
       # === Parameters
-      # recipe, definition, resource<String>:: The thing we provide 
-      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      # recipe, definition, resource<String>:: The thing we provide
+      # version<String>:: A version constraint of the form "OP VERSION",
+      # where OP is one of < <= = > >= ~> and VERSION has
+      # the form x.y.z or x.y.
       #
       # === Returns
-      # versions<Array>:: Returns the list of versions for the platform 
-      def provides(cookbook, *versions)
-        versions.each { |v| _check_version_expression(v) }
-        @providing[cookbook] = versions
-        @providing[cookbook] 
+      # versions<Array>:: Returns the list of versions for the platform
+      def provides(cookbook, *version_args)
+        version = new_args_format(:provides, cookbook, version_args)
+        validate_version_constraint(:provides, cookbook, version)
+        @providing[cookbook] = version
+        @providing[cookbook]
       end
 
       # Adds a cookbook that is replaced by this one, with version checking strings.
       #
       # === Parameters
-      # cookbook<String>:: The cookbook we replace 
-      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      # cookbook<String>:: The cookbook we replace
+      # version<String>:: A version constraint of the form "OP VERSION",
+      # where OP is one of < <= = > >= ~> and VERSION has the form x.y.z or x.y.
       #
       # === Returns
-      # versions<Array>:: Returns the list of versions for the platform 
-      def replaces(cookbook, *versions)
-        versions.each { |v| _check_version_expression(v) }
-        @replacing[cookbook] = versions
-        @replacing[cookbook] 
+      # versions<Array>:: Returns the list of versions for the platform
+      def replaces(cookbook, *version_args)
+        version = new_args_format(:replaces, cookbook, version_args)
+        validate_version_constraint(:replaces, cookbook, version)
+        @replacing[cookbook] = version
+        @replacing[cookbook]
       end
 
-      # Adds a description for a recipe. 
+      # Adds a description for a recipe.
       #
       # === Parameters
       # recipe<String>:: The recipe
       # description<String>:: The description of the recipe
       #
       # === Returns
-      # description<String>:: Returns the current description 
+      # description<String>:: Returns the current description
       def recipe(name, description)
-        @recipes[name] = description 
+        @recipes[name] = description
       end
 
-      # Adds an attribute that a user needs to configure for this cookbook. Takes
+      # Adds an attribute )hat a user needs to configure for this cookbook. Takes
       # a name (with the / notation for a nested attribute), followed by any of
       # these options
       #
@@ -331,11 +360,11 @@ class Chef
       #   default<String>,<Array>,<Hash>:: The default value
       #
       # === Parameters
-      # name<String>:: The name of the attribute ('foo', or 'apache2/log_dir') 
-      # options<Hash>:: The description of the options 
+      # name<String>:: The name of the attribute ('foo', or 'apache2/log_dir')
+      # options<Hash>:: The description of the options
       #
       # === Returns
-      # options<Hash>:: Returns the current options hash 
+      # options<Hash>:: Returns the current options hash
       def attribute(name, options)
         validate(
           options,
@@ -355,7 +384,7 @@ class Chef
         validate_calculated_default_rule(options)
         validate_choice_default_rule(options)
 
-        @attributes[name] = options 
+        @attributes[name] = options
         @attributes[name]
       end
 
@@ -367,43 +396,38 @@ class Chef
             :description => { :kind_of => String }
           }
         )
-        @groupings[name] = options 
+        @groupings[name] = options
         @groupings[name]
       end
 
-      def _check_version_expression(version_string)
-        if version_string =~ /^(>>|>=|=|<=|<<) (.+)$/
-          [ $1, $2 ]
-        else
-          raise ArgumentError, "Version expression #{version_string} is invalid!"
-        end
+      def to_hash
+        {
+          'name'             => self.name,
+          'description'      => self.description,
+          'long_description' => self.long_description,
+          'maintainer'       => self.maintainer,
+          'maintainer_email' => self.maintainer_email,
+          'license'          => self.license,
+          'platforms'        => self.platforms,
+          'dependencies'     => self.dependencies,
+          'recommendations'  => self.recommendations,
+          'suggestions'      => self.suggestions,
+          'conflicting'      => self.conflicting,
+          'providing'        => self.providing,
+          'replacing'        => self.replacing,
+          'attributes'       => self.attributes,
+          'groupings'        => self.groupings,
+          'recipes'          => self.recipes,
+          'version'          => self.version
+        }
       end
 
       def to_json(*a)
-        result = {
-          :name             => self.name,
-          :description      => self.description,
-          :long_description => self.long_description,
-          :maintainer       => self.maintainer,
-          :maintainer_email => self.maintainer_email,
-          :license          => self.license,
-          :platforms        => self.platforms,
-          :dependencies     => self.dependencies,
-          :recommendations  => self.recommendations,
-          :suggestions      => self.suggestions,
-          :conflicting      => self.conflicting,
-          :providing        => self.providing,
-          :replacing        => self.replacing,
-          :attributes       => self.attributes,
-          :groupings        => self.groupings,
-          :recipes          => self.recipes,
-          :version          => self.version
-        }
-        result.to_json(*a)
+        self.to_hash.to_json(*a)
       end
 
       def self.from_hash(o)
-        cm = self.new() 
+        cm = self.new()
         cm.from_hash(o)
         cm
       end
@@ -416,12 +440,12 @@ class Chef
         @maintainer_email             = o['maintainer_email'] if o.has_key?('maintainer_email')
         @license                      = o['license'] if o.has_key?('license')
         @platforms                    = o['platforms'] if o.has_key?('platforms')
-        @dependencies                 = o['dependencies'] if o.has_key?('dependencies')
-        @recommendations              = o['recommendations'] if o.has_key?('recommendations')
-        @suggestions                  = o['suggestions'] if o.has_key?('suggestions')
-        @conflicting                  = o['conflicting'] if o.has_key?('conflicting')
+        @dependencies                 = handle_deprecated_constraints(o['dependencies']) if o.has_key?('dependencies')
+        @recommendations              = handle_deprecated_constraints(o['recommendations']) if o.has_key?('recommendations')
+        @suggestions                  = handle_deprecated_constraints(o['suggestions']) if o.has_key?('suggestions')
+        @conflicting                  = handle_deprecated_constraints(o['conflicting']) if o.has_key?('conflicting')
         @providing                    = o['providing'] if o.has_key?('providing')
-        @replacing                    = o['replacing'] if o.has_key?('replacing')
+        @replacing                    = handle_deprecated_constraints(o['replacing']) if o.has_key?('replacing')
         @attributes                   = o['attributes'] if o.has_key?('attributes')
         @groupings                    = o['groupings'] if o.has_key?('groupings')
         @recipes                      = o['recipes'] if o.has_key?('recipes')
@@ -434,6 +458,19 @@ class Chef
         self.from_hash(o)
       end
 
+      def self.validate_json(json_str)
+        o = Chef::JSONCompat.from_json(json_str)
+        metadata = new()
+        VERSION_CONSTRAINTS.each do |method_name, hash_key|
+          if constraints = o[hash_key]
+           constraints.each do |cb_name, constraints|
+             metadata.send(method_name, cb_name, *Array(constraints))
+           end
+          end
+        end
+        true
+      end
+
       def from_json(string)
         o = Chef::JSONCompat.from_json(string)
         from_hash(o)
@@ -441,6 +478,42 @@ class Chef
 
     private
 
+      def new_args_format(caller_name, dep_name, version_constraints)
+        if version_constraints.empty?
+          ">= 0.0.0"
+        elsif version_constraints.size == 1
+          version_constraints.first
+        else
+          msg=<<-OBSOLETED
+The dependency specification syntax you are using is no longer valid. You may not
+specify more than one version constraint for a particular cookbook.
+Consult http://wiki.opscode.com/display/chef/Metadata for the updated syntax.
+
+Called by: #{caller_name} '#{dep_name}', #{version_constraints.map {|vc| vc.inspect}.join(", ")}
+Called from:
+#{caller[0...5].map {|line| "  " + line}.join("\n")}
+OBSOLETED
+          raise Exceptions::ObsoleteDependencySyntax, msg
+        end
+      end
+
+      def validate_version_constraint(caller_name, dep_name, constraint_str)
+        Chef::VersionConstraint.new(constraint_str)
+      rescue Chef::Exceptions::InvalidVersionConstraint => e
+        Log.debug(e)
+
+        msg=<<-INVALID
+The version constraint syntax you are using is not valid. If you recently
+upgraded to Chef 0.10.0, be aware that you no may longer use "<<" and ">>" for
+'less than' and 'greater than'; use '<' and '>' instead.
+Consult http://wiki.opscode.com/display/chef/Metadata for more information.
+
+Called by: #{caller_name} '#{dep_name}', '#{constraint_str}'
+Called from:
+#{caller[0...5].map {|line| "  " + line}.join("\n")}
+INVALID
+        raise Exceptions::InvalidVersionConstraint, msg
+      end
       # Verify that the given array is an array of strings
       #
       # Raise an exception if the members of the array are not Strings
@@ -495,6 +568,25 @@ class Chef
         end
       end
 
+      # This method translates version constraint strings from
+      # cookbooks with the old format.
+      #
+      # Before we began respecting version constraints, we allowed
+      # multiple constraints to be placed on cookbooks, as well as the
+      # << and >> operators, which are now just < and >. For
+      # specifications with more than one constraint, we return an
+      # empty array (otherwise, we're silently abiding only part of
+      # the contract they have specified to us). If there is only one
+      # constraint, we are replacing the old << and >> with the new <
+      # and >.
+      def handle_deprecated_constraints(specification)
+        specification.inject(Mash.new) do |acc, (cb, constraints)|
+          constraints = Array(constraints)
+          acc[cb] = (constraints.empty? || constraints.size > 1) ? [] : constraints.first.gsub(/>>/, '>').gsub(/<</, '<')
+          acc
+        end
+      end
+
     end
   end
 end