berkshelf 4.0.1 → 4.1.0

data/berkshelf.gemspec

@@ -41,19 +41,21 @@ Gem::Specification.new do |s|
   s.add_dependency 'minitar',              '~> 0.5.4'
   s.add_dependency 'retryable',            '~> 2.0'
   s.add_dependency 'ridley',               '~> 4.3'
-  s.add_dependency 'solve',                '~> 1.1'
+  s.add_dependency 'solve',                '~> 2.0'
   s.add_dependency 'thor',                 '~> 0.19'
-  s.add_dependency 'octokit',              '~> 3.0'
+  s.add_dependency 'octokit',              '~> 4.0'
   s.add_dependency 'celluloid',            '= 0.16.0'
   s.add_dependency 'celluloid-io',         '~> 0.16.1'
 
-  s.add_development_dependency 'aruba',         '~> 0.6'
-  s.add_development_dependency 'chef-zero',     '~> 1.5.0'
-  s.add_development_dependency 'fuubar',        '~> 1.1'
-  s.add_development_dependency 'rake',          '~> 0.9'
+  s.add_development_dependency 'aruba',         '~> 0.10.0' # Lock this here to avoid problems with public API changes
+  s.add_development_dependency 'chef-zero',     '~> 4.0'
+  s.add_development_dependency 'dep_selector',  '~> 1.0'
+  s.add_development_dependency 'fuubar',        '~> 2.0'
+  s.add_development_dependency 'rake',          '~> 10.1'
   s.add_development_dependency 'rspec',         '~> 3.0'
   s.add_development_dependency 'spork',         '~> 0.9'
   s.add_development_dependency 'test-kitchen',  '~> 1.2'
   s.add_development_dependency 'webmock',       '~> 1.11'
   s.add_development_dependency 'yard',          '~> 0.8'
+  s.add_development_dependency 'http',          '~> 0.9.8'
 end

data/features/commands/install.feature

@@ -133,19 +133,19 @@ Feature: berks install
   Scenario: installing a demand from a path location
     Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      cookbook 'example_cookbook', path: '../../fixtures/cookbooks/example_cookbook-0.5.0'
+      cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
       """
     And the Berkshelf API server's cache is up to date
     When I successfully run `berks install`
     Then the output should contain:
       """
-      Using example_cookbook (0.5.0) from source at ../../fixtures/cookbooks/example_cookbook-0.5.0
+      Using example_cookbook (0.5.0) from source at ../../spec/fixtures/cookbooks/example_cookbook-0.5.0
       """
 
   Scenario: installing a demand from a path location with a conflicting constraint
     Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      cookbook 'example_cookbook', '~> 1.0.0', path: '../../fixtures/cookbooks/example_cookbook-0.5.0'
+      cookbook 'example_cookbook', '~> 1.0.0', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
       """
     When I run `berks install`
     Then the output should contain:
@@ -158,13 +158,13 @@ Feature: berks install
       | example_cookbook | 0.5.0 | missing_cookbook >= 1.0.0 |
     And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      cookbook 'example_cookbook', path: '../../fixtures/cookbooks/example_cookbook-0.5.0'
+      cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
       """
     And the Berkshelf API server's cache is up to date
     When I successfully run `berks install`
     Then the output should contain:
       """
-      Using example_cookbook (0.5.0) from source at ../../fixtures/cookbooks/example_cookbook-0.5.0
+      Using example_cookbook (0.5.0) from source at ../../spec/fixtures/cookbooks/example_cookbook-0.5.0
       """
 
   Scenario: installing a demand from a path location locks the graph to that version
@@ -172,7 +172,7 @@ Feature: berks install
       | other_cookbook   | 1.0.0 | example_cookbook ~> 1.0.0 |
     And I have a Berksfile pointing at the local Berkshelf API with:
       """
-      cookbook 'example_cookbook', path: '../../fixtures/cookbooks/example_cookbook-0.5.0'
+      cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
       cookbook 'other_cookbook'
       """
     And the Berkshelf API server's cache is up to date
@@ -185,12 +185,12 @@ Feature: berks install
   Scenario: installing a Berksfile from a remote directory that contains a path location
     Given I have a Berksfile at "subdirectory" pointing at the local Berkshelf API with:
       """
-      cookbook 'example_cookbook', path: '../../../fixtures/cookbooks/example_cookbook-0.5.0'
+      cookbook 'example_cookbook', path: '../../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
       """
     When I successfully run `berks install -b subdirectory/Berksfile`
     Then the output should contain:
       """
-      Using example_cookbook (0.5.0) from source at ../../../fixtures/cookbooks/example_cookbook-0.5.0
+      Using example_cookbook (0.5.0) from source at ../../../spec/fixtures/cookbooks/example_cookbook-0.5.0
       """
 
   Scenario: installing a demand from a Git location
@@ -541,3 +541,100 @@ Feature: berks install
       """
       Using bacon (0.2.0)
       """
+
+  Scenario: when asking for the :ruby solver engine without precedence, no error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :ruby
+    """
+  When I successfully run `berks install`
+  Then the output should contain:
+    """
+    Resolving cookbook dependencies...
+    """
+
+  Scenario: when asking for the :gecode solver engine without precedence, no error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :gecode
+    """
+  When I successfully run `berks install`
+  Then the output should contain:
+    """
+    Resolving cookbook dependencies...
+    """
+
+  Scenario: when asking for an unknown solver engine without precedence, no error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :unknown
+    """
+  When I successfully run `berks install`
+  Then the output should contain:
+    """
+    Resolving cookbook dependencies...
+    """
+
+  Scenario: when preferring the :gecode solver engine, no error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :gecode, :preferred
+    """
+  When I successfully run `berks install`
+  Then the output should contain:
+    """
+    Resolving cookbook dependencies...
+    """
+
+  Scenario: when preferring an unknown solver engine, no error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :unknown, :preferred
+    """
+  When I successfully run `berks install`
+  Then the output should contain:
+    """
+    Resolving cookbook dependencies...
+    """
+
+  Scenario: when requiring an unknown solver engine, an error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :unknown, :required
+    """
+  When I run `berks install`
+  Then the output should contain:
+    """
+    Engine `unknown` is not supported.
+    """
+    And the exit status should be "ArgumentError"
+
+  Scenario: when requiring the :ruby solver engine, no error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :ruby, :required
+    """
+  When I successfully run `berks install`
+  Then the output should contain:
+    """
+    Resolving cookbook dependencies...
+    """
+
+  Scenario: when requiring the :gecode solver engine, no error is raised
+  Given I have a Berksfile pointing at the local Berkshelf API with:
+    """
+    cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
+    solver :gecode, :required
+    """
+  When I successfully run `berks install`
+  Then the output should contain:
+    """
+    Resolving cookbook dependencies...
+    """

data/features/json_formatter.feature

@@ -93,13 +93,13 @@ Feature: --format json
   Scenario: JSON output when running the upload command
     Given I have a Berksfile pointing at the local Berkshelf API with:
       """
-      cookbook 'example_cookbook', path: '../../fixtures/cookbooks/example_cookbook-0.5.0'
+      cookbook 'example_cookbook', path: '../../spec/fixtures/cookbooks/example_cookbook-0.5.0'
       """
     And I write to "Berksfile.lock" with:
       """
       DEPENDENCIES
         example_cookbook
-          path: ../../fixtures/cookbooks/example_cookbook-0.5.0
+          path: ../../spec/fixtures/cookbooks/example_cookbook-0.5.0
 
       GRAPH
         example_cookbook (0.5.0)

data/features/step_definitions/chef/config_steps.rb

@@ -8,5 +8,5 @@ Given /^I do not have a Chef config$/ do
   Berkshelf.chef_config.save
 
   ENV['BERKSHELF_CHEF_CONFIG'] = path
-  set_env 'BERKSHELF_CHEF_CONFIG', path
+  set_environment_variable 'BERKSHELF_CHEF_CONFIG', path
 end

data/features/step_definitions/chef_server_steps.rb

@@ -28,8 +28,8 @@ Given(/^the Chef Server has an environment named "(.*?)"$/) do |name|
 end
 
 Given(/^the Chef Server does not have an environment named "(.*?)"$/) do |name|
-  if chef_server.data_store.exists?(['environments', name])
-    chef_server.data_store.delete(['environments', name])
+  if chef_server.data_store.exists?(['organizations', 'chef', 'environments', name])
+    chef_server.data_store.delete(['organizations', 'chef', 'environments', name])
   end
 end
 

data/features/step_definitions/cli_steps.rb

@@ -1,4 +1,4 @@
 Then /^the exit status should be "(.+)"$/ do |name|
   error = name.split('::').reduce(Berkshelf) { |klass, id| klass.const_get(id) }
-  assert_exit_status(error.status_code)
+  expect(last_command_started).to have_exit_status(error.status_code)
 end

data/features/step_definitions/config_steps.rb

@@ -8,7 +8,7 @@ Given /^I already have a Berkshelf config file$/ do
   Berkshelf.config = config
 
   ENV['BERKSHELF_CONFIG'] = path
-  set_env 'BERKSHELF_CONFIG', path
+  set_environment_variable 'BERKSHELF_CONFIG', path
 end
 
 Given /^I have a Berkshelf config file containing:$/ do |contents|

data/features/step_definitions/environment_steps.rb

@@ -1,7 +1,7 @@
 Given /^the environment variable (.+) is nil$/ do |variable|
-  set_env(variable, nil)
+  set_environment_variable(variable, nil)
 end
 
 Given /^the environment variable (.+) is "(.+)"$/ do |variable, value|
-  set_env(variable, value)
+  set_environment_variable(variable, value)
 end

data/features/step_definitions/filesystem_steps.rb

@@ -5,7 +5,7 @@ World(Berkshelf::RSpec::ChefAPI)
 World(Berkshelf::RSpec::FileSystemMatchers)
 
 Given /^a cookbook named "(.*?)"$/ do |name|
-  create_dir(name)
+  create_directory(name)
   write_file(File.join(name, "metadata.rb"), "name '#{name}'")
 end
 
@@ -24,7 +24,7 @@ Given /^the cookbook store has the git cookbooks:$/ do |cookbooks|
     folder   = "#{name}-#{sha}"
     metadata = File.join(folder, 'metadata.rb')
 
-    create_dir(folder)
+    create_directory(folder)
     write_file(metadata, [
       "name '#{name}'",
       "version '#{version}'"
@@ -93,9 +93,7 @@ Then /^I should have a new cookbook skeleton "(.*?)"$/ do |name|
     file "Berksfile" do
       contains "metadata"
     end
-    file "Gemfile" do
-      contains "gem 'berkshelf'"
-    end
+    file "Gemfile"
     file "metadata.rb"
     file "README.md"
     file "Vagrantfile" do

data/features/step_definitions/json_steps.rb

@@ -17,7 +17,7 @@ end
 Then /^the output should contain JSON:$/ do |data|
   parsed = ERB.new(data).result
   target = JSON.pretty_generate(JSON.parse(parsed).sort_by_key)
-  actual = JSON.pretty_generate(JSON.parse(all_output).sort_by_key)
+  actual = JSON.pretty_generate(JSON.parse(all_commands.map { |c| c.output }.join("\n")).sort_by_key)
 
   expect(actual).to eq(target)
 end

data/features/support/env.rb

@@ -31,8 +31,8 @@ Spork.prefork do
     ENV['BERKSHELF_CONFIG'] = Berkshelf.config.path.to_s
     ENV['BERKSHELF_CHEF_CONFIG'] = chef_config_path.to_s
 
-    Aruba::InProcess.main_class = Berkshelf::Cli::Runner
-    Aruba.process               = Aruba::InProcess
+    aruba.config.command_launcher = :in_process
+    aruba.config.main_class = Berkshelf::Cli::Runner
     @dirs                       = ["spec/tmp/aruba"] # set aruba's temporary directory
 
     stub_kitchen!
@@ -56,20 +56,20 @@ Spork.prefork do
     Berkshelf::RSpec::ChefServer.start(port: CHEF_SERVER_PORT)
     Berkshelf::API::RSpec::Server.start(port: BERKS_API_PORT, endpoints: endpoints) unless windows?
 
-    @aruba_io_wait_seconds = Cucumber::JRUBY ? 7 : 5
+    aruba.config.io_wait_timeout = Cucumber::JRUBY ? 7 : 5
     @aruba_timeout_seconds = Cucumber::JRUBY ? 35 : 15
   end
 
   Before('@spawn') do
-    Aruba.process = Aruba::SpawnProcess
+    aruba.config.command_launcher = :spawn
 
-    set_env('BERKSHELF_PATH', berkshelf_path.to_s)
-    set_env('BERKSHELF_CONFIG', Berkshelf.config.path.to_s)
-    set_env('BERKSHELF_CHEF_CONFIG', chef_config_path.to_s)
+    set_environment_variable('BERKSHELF_PATH', berkshelf_path.to_s)
+    set_environment_variable('BERKSHELF_CONFIG', Berkshelf.config.path.to_s)
+    set_environment_variable('BERKSHELF_CHEF_CONFIG', chef_config_path.to_s)
   end
 
   Before('@slow_process') do
-    @aruba_io_wait_seconds = Cucumber::JRUBY ? 70 : 30
+    aruba.config.io_wait_timeout = Cucumber::JRUBY ? 70 : 30
     @aruba_timeout_seconds = Cucumber::JRUBY ? 140 : 60
   end
 end

data/generator_files/Gemfile.erb

@@ -1,19 +1,5 @@
 source 'https://rubygems.org'
 
-gem 'berkshelf'
-
-# Uncomment these lines if you want to live on the Edge:
-#
-# group :development do
-#   gem "berkshelf", github: "berkshelf/berkshelf"
-#   gem "vagrant", github: "mitchellh/vagrant", tag: "v1.6.3"
-# end
-#
-# group :plugins do
-#   gem "vagrant-berkshelf", github: "berkshelf/vagrant-berkshelf"
-#   gem "vagrant-omnibus", github: "schisamo/vagrant-omnibus"
-# end
-
 <% if options[:foodcritic] -%>
 gem 'thor-foodcritic'
 <% end -%>

data/lib/berkshelf/berksfile.rb

@@ -41,6 +41,14 @@ module Berkshelf
     #   The path on disk to the file representing this instance of Berksfile
     attr_reader :filepath
 
+    # @return [Symbol]
+    #   The solver engine required by this instance of Berksfile
+    attr_reader :required_solver
+
+    # @return [Symbol]
+    #   The solver engine preferred by this instance of Berksfile
+    attr_reader :preferred_solver
+
     # Create a new Berksfile object.
     #
     # @param [String] path
@@ -57,6 +65,10 @@ module Berkshelf
       @dependencies     = Hash.new
       @sources          = Hash.new
 
+      # defaults for what solvers to use
+      @required_solver  = nil
+      @preferred_solver = :gecode
+
       if options[:except] && options[:only]
         raise ArgumentError, 'Cannot specify both :except and :only!'
       elsif options[:except]
@@ -186,6 +198,41 @@ module Berkshelf
     end
     expose :source
 
+    # Configure a specific engine for the 'solve' gem to use when computing dependencies. You may
+    # optionally specify how strong a requirement this is. If omitted, the default precedence is
+    # :preferred.
+    #
+    # If :required is specified and cannot be loaded, Resolver#resolve will raise an ArgumentError.
+    # If :preferred is specified and cannot be loaded, Resolver#resolve silently catch any errors and
+    # use whatever default method the 'solve' gem provides (as of 2.0.1, solve defaults to :ruby).
+    #
+    # @example
+    #   solver :gecode
+    #   solver :gecode, :preferred
+    #   solver :gecode, :required
+    #   solver :ruby
+    #   solver :ruby, :preferred
+    #   solver :ruby, :required
+    #
+    # @param [Symbol] name
+    #   name of engine for solver gem to use for depsolving
+    #
+    # @param [Symbol] precedence
+    #   how strong a requirement using this solver is
+    #   valid values are :required, :preferred
+    #
+    # @raise [ArgumentError]
+    def solver(name, precedence = :preferred)
+      if name && precedence == :required
+        @required_solver = name
+      elsif name && precedence == :preferred
+        @preferred_solver = name
+      else
+        raise ArgumentError, "Invalid solver precedence ':#{precedence}'"
+      end
+    end
+    expose :solver
+
     # @return [Array<Source>]
     def sources
       if @sources.empty?

data/lib/berkshelf/downloader.rb

@@ -101,12 +101,13 @@ module Berkshelf
           return nil
         end
 
-        Net::HTTP.start(url.host, use_ssl: url.scheme == "https",
-          verify_mode: (options[:ssl_verify].nil? || options[:ssl_verify]) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE) do |http|
-          resp = http.get(url.request_uri)
-          return nil unless resp.is_a?(Net::HTTPSuccess)
-          open(archive_path, "wb") { |file| file.write(resp.body) }
-        end
+        # We use Net::HTTP.new and then get here, because Net::HTTP.get does not support proxy settings.
+        http = Net::HTTP.new(url.host,
+                             use_ssl: url.scheme == "https",
+                             verify_mode: (options[:ssl_verify].nil? || options[:ssl_verify]) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE)
+        resp = http.get(url.request_uri)
+        return nil unless resp.is_a?(Net::HTTPSuccess)
+        open(archive_path, "wb") { |file| file.write(resp.body) }
 
         tgz = Zlib::GzipReader.new(File.open(archive_path, "rb"))
         Archive::Tar::Minitar.unpack(tgz, unpack_dir)

data/lib/berkshelf/lockfile.rb

@@ -396,20 +396,27 @@ module Berkshelf
           raise OutdatedDependency.new(graphed, dependency)
         end
 
+        # Locking dependency version to the graphed version if
+        # constraints are satisfied by it.
+        dependency.locked_version = graphed.version
+
         if cookbook = dependency.cached_cookbook
           Berkshelf.log.debug "    Cached cookbook exists"
-          Berkshelf.log.debug "    Checking dependencies on the cached cookbook"
-
-          graphed.dependencies.each do |name, constraint|
-            Berkshelf.log.debug "      Checking #{name} (#{constraint})"
+          Berkshelf.log.debug "    Updating cookbook dependencies if required"
+          graphed.set_dependencies(cookbook.dependencies)
+        end
+      end
 
-            # Unless the cookbook still depends on this key, we want to queue it
-            # for unlocking. This is the magic that prevents transitive
-            # dependency leaking.
-            unless cookbook.dependencies.has_key?(name)
-              Berkshelf.log.debug "        Not found!"
-              unlock(name, true)
-            end
+      # Iteratively remove orphan dependencies
+      orphans = true
+      while orphans do
+        orphans = false
+        graph.each do |cookbook|
+          name = cookbook.name
+          unless dependency?(name) or graph.dependency?(name)
+            Berkshelf.log.debug "#{cookbook} identified as orphan; removing it"
+            unlock(name)
+            orphans = true
           end
         end
       end
@@ -811,6 +818,10 @@ module Berkshelf
               @dependencies[name.to_s] = constraint.to_s
             end
 
+            def set_dependencies(dependencies)
+              @dependencies = dependencies.to_hash
+            end
+
             # @private
             def to_s
               "#{name} (#{version})"