chef-zero 4.2.3 → 4.3.0

data/lib/chef_zero/endpoints/cookbooks_base.rb

@@ -1,65 +1,65 @@
-require 'ffi_yajl'
-require 'chef_zero/rest_base'
-require 'chef_zero/chef_data/data_normalizer'
-
-module ChefZero
-  module Endpoints
-    # Common code for endpoints that return cookbook lists
-    class CookbooksBase < RestBase
-      def format_cookbooks_list(request, cookbooks_list, constraints = {}, num_versions = nil)
-        results = {}
-        filter_cookbooks(cookbooks_list, constraints, num_versions) do |name, versions|
-          versions_list = versions.map do |version|
-            {
-              'url' => build_uri(request.base_uri, request.rest_path[0..1] + ['cookbooks', name, version]),
-              'version' => version
-            }
-          end
-          results[name] = {
-            'url' => build_uri(request.base_uri, request.rest_path[0..1] + ['cookbooks', name]),
-            'versions' => versions_list
-          }
-        end
-        results
-      end
-
-      def all_cookbooks_list(request)
-        result = {}
-        # Race conditions exist here (if someone deletes while listing).  I don't care.
-        data_store.list(request.rest_path[0..1] + ['cookbooks']).each do |name|
-          result[name] = data_store.list(request.rest_path[0..1] + ['cookbooks', name])
-        end
-        result
-      end
-
-      def filter_cookbooks(cookbooks_list, constraints = {}, num_versions = nil)
-        cookbooks_list.keys.sort.each do |name|
-          constraint = Gem::Requirement.new(constraints[name])
-          versions = []
-          cookbooks_list[name].sort_by { |version| Gem::Version.new(version.dup) }.reverse.each do |version|
-            break if num_versions && versions.size >= num_versions
-            if constraint.satisfied_by?(Gem::Version.new(version.dup))
-              versions << version
-            end
-          end
-          yield [name, versions]
-        end
-      end
-
-      def recipe_names(cookbook_name, cookbook)
-        result = []
-        if cookbook['recipes']
-          cookbook['recipes'].each do |recipe|
-            if recipe['path'] == "recipes/#{recipe['name']}" && recipe['name'][-3..-1] == '.rb'
-              if recipe['name'] == 'default.rb'
-                result << cookbook_name
-              end
-              result << "#{cookbook_name}::#{recipe['name'][0..-4]}"
-            end
-          end
-        end
-        result
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/rest_base'
+require 'chef_zero/chef_data/data_normalizer'
+
+module ChefZero
+  module Endpoints
+    # Common code for endpoints that return cookbook lists
+    class CookbooksBase < RestBase
+      def format_cookbooks_list(request, cookbooks_list, constraints = {}, num_versions = nil)
+        results = {}
+        filter_cookbooks(cookbooks_list, constraints, num_versions) do |name, versions|
+          versions_list = versions.map do |version|
+            {
+              'url' => build_uri(request.base_uri, request.rest_path[0..1] + ['cookbooks', name, version]),
+              'version' => version
+            }
+          end
+          results[name] = {
+            'url' => build_uri(request.base_uri, request.rest_path[0..1] + ['cookbooks', name]),
+            'versions' => versions_list
+          }
+        end
+        results
+      end
+
+      def all_cookbooks_list(request)
+        result = {}
+        # Race conditions exist here (if someone deletes while listing).  I don't care.
+        data_store.list(request.rest_path[0..1] + ['cookbooks']).each do |name|
+          result[name] = data_store.list(request.rest_path[0..1] + ['cookbooks', name])
+        end
+        result
+      end
+
+      def filter_cookbooks(cookbooks_list, constraints = {}, num_versions = nil)
+        cookbooks_list.keys.sort.each do |name|
+          constraint = Gem::Requirement.new(constraints[name])
+          versions = []
+          cookbooks_list[name].sort_by { |version| Gem::Version.new(version.dup) }.reverse.each do |version|
+            break if num_versions && versions.size >= num_versions
+            if constraint.satisfied_by?(Gem::Version.new(version.dup))
+              versions << version
+            end
+          end
+          yield [name, versions]
+        end
+      end
+
+      def recipe_names(cookbook_name, cookbook)
+        result = []
+        if cookbook['recipes']
+          cookbook['recipes'].each do |recipe|
+            if recipe['path'] == "recipes/#{recipe['name']}" && recipe['name'][-3..-1] == '.rb'
+              if recipe['name'] == 'default.rb'
+                result << cookbook_name
+              end
+              result << "#{cookbook_name}::#{recipe['name'][0..-4]}"
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/cookbooks_endpoint.rb

@@ -1,19 +1,19 @@
-require 'chef_zero/endpoints/cookbooks_base'
-
-module ChefZero
-  module Endpoints
-    # /cookbooks
-    class CookbooksEndpoint < CookbooksBase
-      def get(request)
-        if request.query_params['num_versions'] == 'all'
-          num_versions = nil
-        elsif request.query_params['num_versions']
-          num_versions = request.query_params['num_versions'].to_i
-        else
-          num_versions = 1
-        end
-        json_response(200, format_cookbooks_list(request, all_cookbooks_list(request), {}, num_versions))
-      end
-    end
-  end
-end
+require 'chef_zero/endpoints/cookbooks_base'
+
+module ChefZero
+  module Endpoints
+    # /cookbooks
+    class CookbooksEndpoint < CookbooksBase
+      def get(request)
+        if request.query_params['num_versions'] == 'all'
+          num_versions = nil
+        elsif request.query_params['num_versions']
+          num_versions = request.query_params['num_versions'].to_i
+        else
+          num_versions = 1
+        end
+        json_response(200, format_cookbooks_list(request, all_cookbooks_list(request), {}, num_versions))
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/data_bag_endpoint.rb

@@ -1,45 +1,45 @@
-require 'ffi_yajl'
-require 'chef_zero/endpoints/rest_list_endpoint'
-require 'chef_zero/endpoints/data_bag_item_endpoint'
-require 'chef_zero/rest_error_response'
-
-module ChefZero
-  module Endpoints
-    # /data/NAME
-    class DataBagEndpoint < RestListEndpoint
-      def initialize(server)
-        super(server, 'id')
-      end
-
-      def post(request)
-        json = FFI_Yajl::Parser.parse(request.body, :create_additions => false)
-        key = identity_keys.map { |k| json[k] }.select { |v| v }.first
-        response = super(request)
-        if response[0] == 201
-          already_json_response(201, DataBagItemEndpoint::populate_defaults(request, request.body, request.rest_path[3], key))
-        else
-          response
-        end
-      end
-
-      def get_key(contents)
-        data_bag_item = FFI_Yajl::Parser.parse(contents, :create_additions => false)
-        if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
-          data_bag_item['raw_data']['id']
-        else
-          data_bag_item['id']
-        end
-      end
-
-      def delete(request)
-        key = request.rest_path[3]
-        delete_data_dir(request, request.rest_path, :recursive)
-        json_response(200, {
-          'chef_type' => 'data_bag',
-          'json_class' => 'Chef::DataBag',
-          'name' => key
-        })
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/endpoints/rest_list_endpoint'
+require 'chef_zero/endpoints/data_bag_item_endpoint'
+require 'chef_zero/rest_error_response'
+
+module ChefZero
+  module Endpoints
+    # /data/NAME
+    class DataBagEndpoint < RestListEndpoint
+      def initialize(server)
+        super(server, 'id')
+      end
+
+      def post(request)
+        json = FFI_Yajl::Parser.parse(request.body, :create_additions => false)
+        key = identity_keys.map { |k| json[k] }.select { |v| v }.first
+        response = super(request)
+        if response[0] == 201
+          already_json_response(201, DataBagItemEndpoint::populate_defaults(request, request.body, request.rest_path[3], key))
+        else
+          response
+        end
+      end
+
+      def get_key(contents)
+        data_bag_item = FFI_Yajl::Parser.parse(contents, :create_additions => false)
+        if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
+          data_bag_item['raw_data']['id']
+        else
+          data_bag_item['id']
+        end
+      end
+
+      def delete(request)
+        key = request.rest_path[3]
+        delete_data_dir(request, request.rest_path, :recursive)
+        json_response(200, {
+          'chef_type' => 'data_bag',
+          'json_class' => 'Chef::DataBag',
+          'name' => key
+        })
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/data_bag_item_endpoint.rb

@@ -1,25 +1,25 @@
-require 'ffi_yajl'
-require 'chef_zero/endpoints/rest_object_endpoint'
-require 'chef_zero/endpoints/data_bag_item_endpoint'
-require 'chef_zero/chef_data/data_normalizer'
-
-module ChefZero
-  module Endpoints
-    # /data/NAME/NAME
-    class DataBagItemEndpoint < RestObjectEndpoint
-      def initialize(server)
-        super(server, 'id')
-      end
-
-      def populate_defaults(request, response_json)
-        DataBagItemEndpoint::populate_defaults(request, response_json, request.rest_path[3], request.rest_path[4])
-      end
-
-      def self.populate_defaults(request, response_json, data_bag, data_bag_item)
-        response = FFI_Yajl::Parser.parse(response_json, :create_additions => false)
-        response = ChefData::DataNormalizer.normalize_data_bag_item(response, data_bag, data_bag_item, request.method)
-        FFI_Yajl::Encoder.encode(response, :pretty => true)
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/endpoints/rest_object_endpoint'
+require 'chef_zero/endpoints/data_bag_item_endpoint'
+require 'chef_zero/chef_data/data_normalizer'
+
+module ChefZero
+  module Endpoints
+    # /data/NAME/NAME
+    class DataBagItemEndpoint < RestObjectEndpoint
+      def initialize(server)
+        super(server, 'id')
+      end
+
+      def populate_defaults(request, response_json)
+        DataBagItemEndpoint::populate_defaults(request, response_json, request.rest_path[3], request.rest_path[4])
+      end
+
+      def self.populate_defaults(request, response_json, data_bag, data_bag_item)
+        response = FFI_Yajl::Parser.parse(response_json, :create_additions => false)
+        response = ChefData::DataNormalizer.normalize_data_bag_item(response, data_bag, data_bag_item, request.method)
+        FFI_Yajl::Encoder.encode(response, :pretty => true)
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/data_bags_endpoint.rb

@@ -1,23 +1,23 @@
-require 'ffi_yajl'
-require 'chef_zero/endpoints/rest_list_endpoint'
-
-module ChefZero
-  module Endpoints
-    # /data
-    class DataBagsEndpoint < RestListEndpoint
-      def post(request)
-        contents = request.body
-        json = FFI_Yajl::Parser.parse(contents, :create_additions => false)
-        name = identity_keys.map { |k| json[k] }.select { |v| v }.first
-        if name.nil?
-          error(400, "Must specify #{identity_keys.map { |k| k.inspect }.join(' or ')} in JSON")
-        elsif exists_data_dir?(request, request.rest_path[0..1] + ['data', name])
-          error(409, "Object already exists")
-        else
-          create_data_dir(request, request.rest_path[0..1] + ['data'], name, :recursive)
-          json_response(201, {"uri" => "#{build_uri(request.base_uri, request.rest_path + [name])}"})
-        end
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/endpoints/rest_list_endpoint'
+
+module ChefZero
+  module Endpoints
+    # /data
+    class DataBagsEndpoint < RestListEndpoint
+      def post(request)
+        contents = request.body
+        json = FFI_Yajl::Parser.parse(contents, :create_additions => false)
+        name = identity_keys.map { |k| json[k] }.select { |v| v }.first
+        if name.nil?
+          error(400, "Must specify #{identity_keys.map { |k| k.inspect }.join(' or ')} in JSON")
+        elsif exists_data_dir?(request, request.rest_path[0..1] + ['data', name])
+          error(409, "Object already exists")
+        else
+          create_data_dir(request, request.rest_path[0..1] + ['data'], name, :recursive)
+          json_response(201, {"uri" => "#{build_uri(request.base_uri, request.rest_path + [name])}"})
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/environment_cookbook_endpoint.rb

@@ -1,24 +1,24 @@
-require 'ffi_yajl'
-require 'chef_zero/endpoints/cookbooks_base'
-
-module ChefZero
-  module Endpoints
-    # /environments/NAME/cookbooks/NAME
-    class EnvironmentCookbookEndpoint < CookbooksBase
-      def get(request)
-        cookbook_name = request.rest_path[5]
-        environment = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..3]), :create_additions => false)
-        constraints = environment['cookbook_versions'] || {}
-        cookbook_versions = list_data(request, request.rest_path[0..1] + request.rest_path[4..5])
-        if request.query_params['num_versions'] == 'all'
-          num_versions = nil
-        elsif request.query_params['num_versions']
-          num_versions = request.query_params['num_versions'].to_i
-        else
-          num_versions = nil
-        end
-        json_response(200, format_cookbooks_list(request, { cookbook_name => cookbook_versions }, constraints, num_versions))
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/endpoints/cookbooks_base'
+
+module ChefZero
+  module Endpoints
+    # /environments/NAME/cookbooks/NAME
+    class EnvironmentCookbookEndpoint < CookbooksBase
+      def get(request)
+        cookbook_name = request.rest_path[5]
+        environment = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..3]), :create_additions => false)
+        constraints = environment['cookbook_versions'] || {}
+        cookbook_versions = list_data(request, request.rest_path[0..1] + request.rest_path[4..5])
+        if request.query_params['num_versions'] == 'all'
+          num_versions = nil
+        elsif request.query_params['num_versions']
+          num_versions = request.query_params['num_versions'].to_i
+        else
+          num_versions = nil
+        end
+        json_response(200, format_cookbooks_list(request, { cookbook_name => cookbook_versions }, constraints, num_versions))
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/environment_cookbook_versions_endpoint.rb

@@ -1,123 +1,123 @@
-require 'ffi_yajl'
-require 'chef_zero/rest_base'
-require 'chef_zero/rest_error_response'
-
-module ChefZero
-  module Endpoints
-    # /environments/NAME/cookbook_versions
-    class EnvironmentCookbookVersionsEndpoint < RestBase
-
-      def post(request)
-        cookbook_names = list_data(request, request.rest_path[0..1] + ['cookbooks'])
-
-        # Get the list of cookbooks and versions desired by the runlist
-        desired_versions = {}
-        run_list = FFI_Yajl::Parser.parse(request.body, :create_additions => false)['run_list']
-        run_list.each do |run_list_entry|
-          if run_list_entry =~ /(.+)::.+\@(.+)/ || run_list_entry =~ /(.+)\@(.+)/
-            raise RestErrorResponse.new(412, "No such cookbook: #{$1}") if !cookbook_names.include?($1)
-            raise RestErrorResponse.new(412, "No such cookbook version for cookbook #{$1}: #{$2}") if !list_data(request, request.rest_path[0..1] + ['cookbooks', $1]).include?($2)
-            desired_versions[$1] = [ $2 ]
-          else
-            desired_cookbook = run_list_entry.split('::')[0]
-            raise RestErrorResponse.new(412, "No such cookbook: #{desired_cookbook}") if !cookbook_names.include?(desired_cookbook)
-            desired_versions[desired_cookbook] = list_data(request, request.rest_path[0..1] + ['cookbooks', desired_cookbook])
-          end
-        end
-
-        # Filter by environment constraints
-        environment = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..3]), :create_additions => false)
-        environment_constraints = environment['cookbook_versions'] || {}
-
-        desired_versions.each_key do |name|
-          desired_versions = filter_by_constraint(desired_versions, name, environment_constraints[name])
-        end
-
-        # Depsolve!
-        solved = depsolve(request, desired_versions.keys, desired_versions, environment_constraints)
-        if !solved
-          if @last_missing_dep && !cookbook_names.include?(@last_missing_dep)
-            return raise RestErrorResponse.new(412, "No such cookbook: #{@last_missing_dep}")
-          elsif @last_constraint_failure
-            return raise RestErrorResponse.new(412, "Could not satisfy version constraints for: #{@last_constraint_failure}")
-          else
-
-            return raise RestErrorResponse.new(412, "Unsolvable versions!")
-          end
-        end
-
-        result = {}
-        solved.each_pair do |name, versions|
-          cookbook = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..1] + ['cookbooks', name, versions[0]]), :create_additions => false)
-          result[name] = ChefData::DataNormalizer.normalize_cookbook(self, request.rest_path[0..1], cookbook, name, versions[0], request.base_uri, 'MIN')
-        end
-        json_response(200, result)
-      end
-
-      def depsolve(request, unsolved, desired_versions, environment_constraints)
-        desired_versions.each do |cb, ver|
-          if ver.empty?
-            @last_constraint_failure = cb
-            return nil
-          end
-        end
-
-        # If everything is already
-        solve_for = unsolved[0]
-        return desired_versions if !solve_for
-
-        # Go through each desired version of this cookbook, starting with the latest,
-        # until we find one we can solve successfully with
-        sort_versions(desired_versions[solve_for]).each do |desired_version|
-          new_desired_versions = desired_versions.clone
-          new_desired_versions[solve_for] = [ desired_version ]
-          new_unsolved = unsolved[1..-1]
-
-          # Pick this cookbook, and add dependencies
-          cookbook_obj = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..1] + ['cookbooks', solve_for, desired_version]), :create_additions => false)
-          cookbook_metadata = cookbook_obj['metadata'] || {}
-          cookbook_dependencies = cookbook_metadata['dependencies'] || {}
-          dep_not_found = false
-          cookbook_dependencies.each_pair do |dep_name, dep_constraint|
-            # If the dep is not already in the list, add it to the list to solve
-            # and bring in all environment-allowed cookbook versions to desired_versions
-            if !new_desired_versions.has_key?(dep_name)
-              new_unsolved = new_unsolved + [dep_name]
-              # If the dep is missing, we will try other versions of the cookbook that might not have the bad dep.
-              if !exists_data_dir?(request, request.rest_path[0..1] + ['cookbooks', dep_name])
-                @last_missing_dep = dep_name.to_s
-                dep_not_found = true
-                break
-              end
-              new_desired_versions[dep_name] = list_data(request, request.rest_path[0..1] + ['cookbooks', dep_name])
-              new_desired_versions = filter_by_constraint(new_desired_versions, dep_name, environment_constraints[dep_name])
-            end
-            new_desired_versions = filter_by_constraint(new_desired_versions, dep_name, dep_constraint)
-          end
-
-          next if dep_not_found
-
-          # Depsolve children with this desired version!  First solution wins.
-          result = depsolve(request, new_unsolved, new_desired_versions, environment_constraints)
-          return result if result
-        end
-        return nil
-      end
-
-      def sort_versions(versions)
-        result = versions.sort_by { |version| Gem::Version.new(version.dup) }
-        result.reverse
-      end
-
-      def filter_by_constraint(versions, cookbook_name, constraint)
-        return versions if !constraint
-        constraint = Gem::Requirement.new(constraint)
-        new_versions = versions[cookbook_name]
-        new_versions = new_versions.select { |version| constraint.satisfied_by?(Gem::Version.new(version.dup)) }
-        result = versions.clone
-        result[cookbook_name] = new_versions
-        result
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/rest_base'
+require 'chef_zero/rest_error_response'
+
+module ChefZero
+  module Endpoints
+    # /environments/NAME/cookbook_versions
+    class EnvironmentCookbookVersionsEndpoint < RestBase
+
+      def post(request)
+        cookbook_names = list_data(request, request.rest_path[0..1] + ['cookbooks'])
+
+        # Get the list of cookbooks and versions desired by the runlist
+        desired_versions = {}
+        run_list = FFI_Yajl::Parser.parse(request.body, :create_additions => false)['run_list']
+        run_list.each do |run_list_entry|
+          if run_list_entry =~ /(.+)::.+\@(.+)/ || run_list_entry =~ /(.+)\@(.+)/
+            raise RestErrorResponse.new(412, "No such cookbook: #{$1}") if !cookbook_names.include?($1)
+            raise RestErrorResponse.new(412, "No such cookbook version for cookbook #{$1}: #{$2}") if !list_data(request, request.rest_path[0..1] + ['cookbooks', $1]).include?($2)
+            desired_versions[$1] = [ $2 ]
+          else
+            desired_cookbook = run_list_entry.split('::')[0]
+            raise RestErrorResponse.new(412, "No such cookbook: #{desired_cookbook}") if !cookbook_names.include?(desired_cookbook)
+            desired_versions[desired_cookbook] = list_data(request, request.rest_path[0..1] + ['cookbooks', desired_cookbook])
+          end
+        end
+
+        # Filter by environment constraints
+        environment = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..3]), :create_additions => false)
+        environment_constraints = environment['cookbook_versions'] || {}
+
+        desired_versions.each_key do |name|
+          desired_versions = filter_by_constraint(desired_versions, name, environment_constraints[name])
+        end
+
+        # Depsolve!
+        solved = depsolve(request, desired_versions.keys, desired_versions, environment_constraints)
+        if !solved
+          if @last_missing_dep && !cookbook_names.include?(@last_missing_dep)
+            return raise RestErrorResponse.new(412, "No such cookbook: #{@last_missing_dep}")
+          elsif @last_constraint_failure
+            return raise RestErrorResponse.new(412, "Could not satisfy version constraints for: #{@last_constraint_failure}")
+          else
+
+            return raise RestErrorResponse.new(412, "Unsolvable versions!")
+          end
+        end
+
+        result = {}
+        solved.each_pair do |name, versions|
+          cookbook = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..1] + ['cookbooks', name, versions[0]]), :create_additions => false)
+          result[name] = ChefData::DataNormalizer.normalize_cookbook(self, request.rest_path[0..1], cookbook, name, versions[0], request.base_uri, 'MIN')
+        end
+        json_response(200, result)
+      end
+
+      def depsolve(request, unsolved, desired_versions, environment_constraints)
+        desired_versions.each do |cb, ver|
+          if ver.empty?
+            @last_constraint_failure = cb
+            return nil
+          end
+        end
+
+        # If everything is already
+        solve_for = unsolved[0]
+        return desired_versions if !solve_for
+
+        # Go through each desired version of this cookbook, starting with the latest,
+        # until we find one we can solve successfully with
+        sort_versions(desired_versions[solve_for]).each do |desired_version|
+          new_desired_versions = desired_versions.clone
+          new_desired_versions[solve_for] = [ desired_version ]
+          new_unsolved = unsolved[1..-1]
+
+          # Pick this cookbook, and add dependencies
+          cookbook_obj = FFI_Yajl::Parser.parse(get_data(request, request.rest_path[0..1] + ['cookbooks', solve_for, desired_version]), :create_additions => false)
+          cookbook_metadata = cookbook_obj['metadata'] || {}
+          cookbook_dependencies = cookbook_metadata['dependencies'] || {}
+          dep_not_found = false
+          cookbook_dependencies.each_pair do |dep_name, dep_constraint|
+            # If the dep is not already in the list, add it to the list to solve
+            # and bring in all environment-allowed cookbook versions to desired_versions
+            if !new_desired_versions.has_key?(dep_name)
+              new_unsolved = new_unsolved + [dep_name]
+              # If the dep is missing, we will try other versions of the cookbook that might not have the bad dep.
+              if !exists_data_dir?(request, request.rest_path[0..1] + ['cookbooks', dep_name])
+                @last_missing_dep = dep_name.to_s
+                dep_not_found = true
+                break
+              end
+              new_desired_versions[dep_name] = list_data(request, request.rest_path[0..1] + ['cookbooks', dep_name])
+              new_desired_versions = filter_by_constraint(new_desired_versions, dep_name, environment_constraints[dep_name])
+            end
+            new_desired_versions = filter_by_constraint(new_desired_versions, dep_name, dep_constraint)
+          end
+
+          next if dep_not_found
+
+          # Depsolve children with this desired version!  First solution wins.
+          result = depsolve(request, new_unsolved, new_desired_versions, environment_constraints)
+          return result if result
+        end
+        return nil
+      end
+
+      def sort_versions(versions)
+        result = versions.sort_by { |version| Gem::Version.new(version.dup) }
+        result.reverse
+      end
+
+      def filter_by_constraint(versions, cookbook_name, constraint)
+        return versions if !constraint
+        constraint = Gem::Requirement.new(constraint)
+        new_versions = versions[cookbook_name]
+        new_versions = new_versions.select { |version| constraint.satisfied_by?(Gem::Version.new(version.dup)) }
+        result = versions.clone
+        result[cookbook_name] = new_versions
+        result
+      end
+    end
+  end
+end