berkshelf 1.4.6 → 2.0.0.beta

data/features/update_command.feature

@@ -1,55 +1,136 @@
-Feature: update
+Feature: update command
   As a user
   I want a way to update the versions without clearing out the files I've downloaded
   So that I can update faster than a clean install
 
-  Scenario: knife berkshelf update
+  Scenario: updating with the old lockfile format
     Given I write to "Berksfile" with:
       """
-      cookbook "artifact", "0.10.0"
+      site :opscode
+      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
       """
     Given I write to "Berksfile.lock" with:
       """
-      cookbook 'artifact', :locked_version => '0.1.0'
+      cookbook 'berkshelf-cookbook-fixture', :locked_version => '0.1.0'
       """
     When I successfully run `berks update`
-    Then the file "Berksfile.lock" should contain exactly:
-      """
-      cookbook 'artifact', :locked_version => '0.10.0'
+    Then the output should contain "You are using the old lockfile format. Attempting to convert..."
+    Then the file "Berksfile.lock" should contain JSON:
+      """
+      {
+        "sha":"b2714a4f9bdf500cb20267067160a0b3c1d8404c",
+        "sources":{
+          "berkshelf-cookbook-fixture":{
+            "locked_version":"0.2.0",
+            "constraint":"~> 0.1"
+          }
+        }
+      }
       """
 
-  Scenario: knife berkshelf update a single cookbook
+  Scenario: Updating all cookbooks
     Given I write to "Berksfile" with:
       """
-      cookbook "artifact", "0.10.0"
-      cookbook "build-essential", "~> 1.1.0"
+      site :opscode
+      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
+      cookbook 'hostsfile', '~> 1.0.0'
       """
     Given I write to "Berksfile.lock" with:
       """
-      cookbook 'artifact', :locked_version => '0.10.0'
-      cookbook 'build-essential', :locked_version => '1.1.0'
+      {
+        "sha":"9d10199aa2652f9e965149c4346db20c78e97553",
+        "sources":{
+          "berkshelf-cookbook-fixture":{
+            "locked_version":"0.1.0",
+            "constraint":"~> 0.1"
+          },
+          "hostsfile":{
+            "locked_version":"1.0.1",
+            "constraint":"= 1.0.1"
+          }
+        }
+      }
+      """
+    When I successfully run `berks update`
+    Then the file "Berksfile.lock" should contain JSON:
+      """
+      {
+        "sha":"69b2e00e970d2bb6a9b1d09aeb3e6a17ef3df955",
+        "sources":{
+          "berkshelf-cookbook-fixture":{
+            "locked_version":"0.2.0",
+            "constraint":"~> 0.1"
+          },
+          "hostsfile":{
+            "locked_version":"1.0.1",
+            "constraint":"~> 1.0.0"
+          }
+        }
+      }
       """
-    When I successfully run `berks update build-essential`
-    Then the file "Berksfile.lock" should contain exactly:
+
+  Scenario: Updating a single cookbook
+    Given I write to "Berksfile" with:
       """
-      cookbook 'artifact', :locked_version => '0.10.0'
-      cookbook 'build-essential', :locked_version => '1.1.2'
+      site :opscode
+      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
+      cookbook 'hostsfile', '~> 1.0.0'
+      """
+    And I write to "Berksfile.lock" with:
+      """
+      {
+        "sha":"9d10199aa2652f9e965149c4346db20c78e97553",
+        "sources":{
+          "berkshelf-cookbook-fixture":{
+            "locked_version":"0.1.0",
+            "constraint":"~> 0.1"
+          },
+          "hostsfile":{
+            "locked_version":"1.0.0",
+            "constraint":"~> 1.0.0"
+          }
+        }
+      }
+      """
+    And I successfully run `berks update berkshelf-cookbook-fixture`
+    Then the file "Berksfile.lock" should contain JSON:
+      """
+      {
+        "sha":"69b2e00e970d2bb6a9b1d09aeb3e6a17ef3df955",
+        "sources":{
+          "berkshelf-cookbook-fixture":{
+            "locked_version":"0.2.0",
+            "constraint":"~> 0.1"
+          },
+          "hostsfile":{
+            "locked_version":"1.0.0",
+            "constraint":"~> 1.0.0"
+          }
+        }
+      }
       """
 
-  Scenario: knife berkshelf update a cookbook that isn't in the Berksfile
+  Scenario: Update a cookbook that doesn't exist
     Given I write to "Berksfile" with:
       """
-      cookbook "artifact", "0.10.0"
-      cookbook "build-essential", "~> 1.1.0"
+      site :opscode
+      cookbook 'berkshelf-cookbook-fixture', '~> 0.1'
       """
     Given I write to "Berksfile.lock" with:
       """
-      cookbook 'artifact', :locked_version => '0.10.0'
-      cookbook 'build-essential', :locked_version => '1.1.0'
-      """
-    When I run `berks update foo`
+      {
+        "sha":"23150cfe61b7b86882013c8664883058560b899d",
+        "sources":{
+          "berkshelf-cookbook-fixture":{
+            "locked_version":"0.1.0",
+            "constraint":"~> 0.1"
+          }
+        }
+      }
+      """
+    When I run `berks update non-existent-cookbook`
     Then the output should contain:
       """
-      Could not find cookbooks 'foo' in any of the sources. Is it in your Berksfile?
+      Could not find cookbooks 'non-existent-cookbook' in any of the sources. Is it in your Berksfile?
       """
     And the CLI should exit with the status code for error "CookbookNotFound"

data/features/upload_command.feature

@@ -216,17 +216,3 @@ Feature: upload command
       | ntp |
       | vim |
     And the exit status should be 0
-
-  Scenario: Raise exception uploading an invalid cookbook
-    Given a cookbook named "cookbook with spaces"
-    And I write to "Berksfile" with:
-      """
-      cookbook 'cookbook with spaces', path: './cookbook with spaces'
-      """
-    When I run `berks upload`
-    Then the output should contain:
-      """
-      The cookbook 'cookbook with spaces' has invalid filenames:
-      """
-    And the CLI should exit with the status code for error "InvalidCookbookFiles"
-

data/features/vendor_install.feature

@@ -7,13 +7,13 @@ Feature: install cookbooks to a given vendor path
     Given I write to "Berksfile" with:
       """
       site :opscode
-      cookbook "artifact", "0.10.0"
+      cookbook 'berkshelf-cookbook-fixture', '1.0.0'
       """
     When I run the install command with flags:
       | --path vendor/cookbooks |
     Then the cookbook store should have the cookbooks:
-      | artifact | 0.10.0 |
+      | berkshelf-cookbook-fixture | 1.0.0 |
     Then the following directories should exist:
       | vendor/cookbooks          |
-      | vendor/cookbooks/artifact |
+      | vendor/cookbooks/berkshelf-cookbook-fixture |
     And the exit status should be 0

data/generator_files/Vagrantfile.erb

@@ -9,18 +9,18 @@ Vagrant.configure("2") do |config|
   config.vm.hostname = "<%= "#{cookbook_name.gsub('_','-')}-berkshelf" %>"
 
   # Every Vagrant virtual environment requires a box to build off of.
-  config.vm.box = "<%= options[:berkshelf_config].vagrant.vm.box %>"
+  config.vm.box = "<%= berkshelf_config.vagrant.vm.box %>"
 
   # The url from where the 'config.vm.box' box will be fetched if it
   # doesn't already exist on the user's system.
-  config.vm.box_url = "<%= options[:berkshelf_config].vagrant.vm.box_url %>"
+  config.vm.box_url = "<%= berkshelf_config.vagrant.vm.box_url %>"
 
   # Assign this VM to a host-only network IP, allowing you to access it
   # via the IP. Host-only networks can talk to the host machine as well as
   # any other machines on the same network, but cannot be accessed (through this
   # network interface) by any external networks.
-<% if options[:berkshelf_config].vagrant.vm.network.hostonly.present? -%>
-  config.vm.network :private_network, ip: "<%= options[:berkshelf_config].vagrant.vm.network.hostonly %>"
+<% if berkshelf_config.vagrant.vm.network.hostonly.present? -%>
+  config.vm.network :private_network, ip: "<%= berkshelf_config.vagrant.vm.network.hostonly %>"
 <% else %>
   config.vm.network :private_network, ip: "192.168.33.10"
 <% end -%>
@@ -28,7 +28,7 @@ Vagrant.configure("2") do |config|
   # Create a public network, which generally matched to bridged network.
   # Bridged networks make the machine appear as another physical device on
   # your network.
-<% if options[:berkshelf_config].vagrant.vm.network.bridged -%>
+<% if berkshelf_config.vagrant.vm.network.bridged -%>
   config.vm.network :public_network
 <% else %>
   # config.vm.network :public_network
@@ -37,7 +37,7 @@ Vagrant.configure("2") do |config|
   # Create a forwarded port mapping which allows access to a specific port
   # within the machine from a port on the host machine. In the example below,
   # accessing "localhost:8080" will access port 80 on the guest machine.
-<% options[:berkshelf_config].vagrant.vm.forward_port.each do |guest, host| %>
+<% berkshelf_config.vagrant.vm.forward_port.each do |guest, host| %>
   config.vm.network :forwarded_port, guest: <%= guest %>, host: <%= host %>
 <% end -%>
 
@@ -80,11 +80,11 @@ Vagrant.configure("2") do |config|
   # to skip installing and copying to Vagrant's shelf.
   # config.berkshelf.except = []
 
-<% if options[:berkshelf_config].vagrant.vm.provision == "chef_client" -%>
+<% if berkshelf_config.vagrant.vm.provision == "chef_client" -%>
   config.vm.provision :chef_client do |chef|
-    chef.chef_server_url        = "<%= options[:berkshelf_config].chef.chef_server_url %>"
-    chef.validation_client_name = "<%= options[:berkshelf_config].chef.validation_client_name %>"
-    chef.validation_key_path    = "<%= options[:berkshelf_config].chef.validation_key_path %>"
+    chef.chef_server_url        = "<%= berkshelf_config.chef.chef_server_url %>"
+    chef.validation_client_name = "<%= berkshelf_config.chef.validation_client_name %>"
+    chef.validation_key_path    = "<%= berkshelf_config.chef.validation_key_path %>"
 
     chef.run_list = [
   <% if options[:chef_minitest] -%>
@@ -93,7 +93,7 @@ Vagrant.configure("2") do |config|
       "recipe[<%= cookbook_name %>::default]"
     ]
   end
-<% elsif options[:berkshelf_config].vagrant.vm.provision == "chef_solo" -%>
+<% elsif berkshelf_config.vagrant.vm.provision == "chef_solo" -%>
   config.vm.provision :chef_solo do |chef|
     chef.json = {
       :mysql => {

data/lib/berkshelf.rb

@@ -1,9 +1,10 @@
-require 'chozo/core_ext'
 require 'active_support/core_ext'
 require 'archive/tar/minitar'
+require 'celluloid'
+require 'chozo/core_ext'
 require 'forwardable'
 require 'hashie'
-require 'multi_json'
+require 'json'
 require 'pathname'
 require 'ridley'
 require 'solve'
@@ -11,7 +12,6 @@ require 'thor'
 require 'tmpdir'
 require 'uri'
 require 'zlib'
-require 'celluloid'
 
 require 'berkshelf/core_ext'
 require 'berkshelf/errors'
@@ -56,9 +56,10 @@ module Berkshelf
       @root ||= Pathname.new(File.expand_path('../', File.dirname(__FILE__)))
     end
 
-    # @return [::Thor::Shell::Color]
+    # @return [Thor::Shell::Color, Thor::Shell::Basic]
+    #   A basic shell on Windows, colored everywhere else
     def ui
-      @ui ||= ::Thor::Shell::Color.new
+      @ui ||= Thor::Base.shell.new
     end
 
     # Returns the filepath to the location Berskhelf will use for

data/lib/berkshelf/berksfile.rb

@@ -83,6 +83,12 @@ module Berkshelf
       @cached_cookbooks = nil
     end
 
+    # @return [String]
+    #   the shasum for the Berksfile
+    def sha
+      @sha ||= Digest::SHA1.hexdigest File.read(filepath.to_s)
+    end
+
     # Add a cookbook source to the Berksfile to be retrieved and have it's dependencies recursively retrieved
     # and resolved.
     #
@@ -283,24 +289,31 @@ module Berkshelf
       @sources.has_key?(source.to_s)
     end
 
+    # The list of cookbook sources specified in this Berksfile
+    #
+    # @param [Array] sources
+    #   the list of sources to filter
+    #
     # @option options [Symbol, Array] :except
-    #   Group(s) to exclude to exclude from the returned Array of sources
+    #   group(s) to exclude to exclude from the returned Array of sources
     #   group to not be installed
     # @option options [Symbol, Array] :only
-    #   Group(s) to include which will cause any sources marked as a member of the
+    #   group(s) to include which will cause any sources marked as a member of the
     #   group to be installed and all others to be ignored
     # @option cookbooks [String, Array] :cookbooks
-    #   Names of the cookbooks to retrieve sources for
+    #   names of the cookbooks to retrieve sources for
     #
-    # @raise [Berkshelf::ArgumentError] if a value for both :except and :only is provided
+    # @raise [Berkshelf::ArgumentError]
+    #   if a value for both :except and :only is provided
     #
     # @return [Array<Berkshelf::CookbookSource>]
+    #   the list of cookbook sources that match the given options
     def sources(options = {})
-      l_sources = @sources.collect { |name, source| source }.flatten
+      l_sources = @sources.values
 
-      cookbooks = Array(options.fetch(:cookbooks, nil))
-      except    = Array(options.fetch(:except, nil)).collect(&:to_sym)
-      only      = Array(options.fetch(:only, nil)).collect(&:to_sym)
+      cookbooks = Array(options[:cookbooks])
+      except    = Array(options[:except]).collect(&:to_sym)
+      only      = Array(options[:only]).collect(&:to_sym)
 
       case
       when !except.empty? && !only.empty?
@@ -309,7 +322,7 @@ module Berkshelf
         if !except.empty? && !only.empty?
           Berkshelf.ui.warn "Cookbooks were specified, ignoring :except and :only"
         end
-        l_sources.select { |source| options[:cookbooks].include?(source.name) }
+        l_sources.select { |source| cookbooks.include?(source.name) }
       when !except.empty?
         l_sources.select { |source| (except & source.groups).empty? }
       when !only.empty?
@@ -319,6 +332,16 @@ module Berkshelf
       end
     end
 
+    # Find a source defined in this berksfile by name.
+    #
+    # @param [String] name
+    #   the name of the cookbook source to search for
+    # @return [Berkshelf::CookbookSource, nil]
+    #   the cookbook source, or nil if one does not exist
+    def find(name)
+      @sources[name]
+    end
+
     # @return [Hash]
     #   a hash containing group names as keys and an array of CookbookSources
     #   that are a member of that group as values
@@ -353,6 +376,33 @@ module Berkshelf
     end
     alias_method :get_source, :[]
 
+    # Install the sources listed in the Berksfile, respecting the locked
+    # versions in the Berksfile.lock.
+    #
+    # 1. Check that a lockfile exists. If a lockfile does not exist, all
+    #    sources are considered to be "unlocked". If a lockfile is specified, a
+    #    definition is created via the following algorithm:
+    #
+    #    - Compare the SHA of the current Berksfile with the last-known SHA.
+    #    - If the SHAs match, the Berksfile has not been updated, so we rely
+    #      solely on the locked sources.
+    #    - If the SHAs don't match, then the Berksfile has diverged from the
+    #      lockfile, which means some sources are outdated. For each unlocked
+    #      source, see if there exists a locked version that still satisfies
+    #      the version constraint in the Berksfile. If there exists such a
+    #      source, remove it from the list of unlocked sources. If not, then
+    #      either a version constraint has changed, or a new source has been
+    #      added to the Berksfile. In the event that a locked_source exists,
+    #      but it no longer satisfies the constraint, this method will raise
+    #      a {Berkshelf::OutdatedCookbookSource}, and inform the user to run
+    #      <tt>berks update COOKBOOK</tt> to remedy the issue.
+    #    - Remove any locked sources that no longer exist in the Berksfile
+    #      (i.e. a cookbook source was removed from the Berksfile).
+    #
+    # 2. Resolve the collection of locked and unlocked sources.
+    #
+    # 3. Write out a new lockfile.
+    #
     # @option options [Symbol, Array] :except
     #   Group(s) to exclude which will cause any sources marked as a member of the
     #   group to not be installed
@@ -363,16 +413,26 @@ module Berkshelf
     #   a path to "vendor" the cached_cookbooks resolved by the resolver. Vendoring
     #   is a technique for packaging all cookbooks resolved by a Berksfile.
     #
+    # @raise [Berkshelf::OutdatedCookbookSource]
+    #   if the lockfile constraints do not satisfy the Berskfile constraints
+    # @raise [Berkshelf::ArgumentError]
+    #   if there are missing or conflicting options
+    #
     # @return [Array<Berkshelf::CachedCookbook>]
     def install(options = {})
-      resolver = Resolver.new(self, sources: sources(options))
+      if self.sha == lockfile.sha
+        local_sources = locked_sources
+      else
+        local_sources = apply_lockfile(sources(options))
+      end
 
-      @cached_cookbooks = resolver.resolve
-      write_lockfile(resolver.sources) unless lockfile_present?
+      resolver          = resolve(local_sources)
+      @cached_cookbooks = resolver[:solution]
+      local_sources     = resolver[:sources]
 
-      if options[:path]
-        self.class.vendor(@cached_cookbooks, options[:path])
-      end
+      self.class.vendor(@cached_cookbooks, options[:path]) if options[:path]
+
+      lockfile.update(local_sources, sha: self.sha)
 
       self.cached_cookbooks
     end
@@ -386,25 +446,15 @@ module Berkshelf
     # @option cookbooks [String, Array] :cookbooks
     #   Names of the cookbooks to retrieve sources for
     def update(options = {})
-      resolver = Resolver.new(self, sources: sources(options))
-
-      cookbooks         = resolver.resolve
-      sources           = resolver.sources
-      missing_cookbooks = (options[:cookbooks] - cookbooks.map(&:cookbook_name))
+      validate_cookbook_names!(options)
 
-      unless missing_cookbooks.empty?
-        msg = "Could not find cookbooks #{missing_cookbooks.collect{|cookbook| "'#{cookbook}'"}.join(', ')}"
-        msg << " in any of the sources. #{missing_cookbooks.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
-        raise Berkshelf::CookbookNotFound, msg
-      end
+      # Unlock any/all specified cookbooks
+      sources(options).each { |source| lockfile.unlock(source) }
 
-      update_lockfile(sources)
+      lockfile.reset_sha!
 
-      if options[:path]
-        self.class.vendor(cookbooks, options[:path])
-      end
-
-      cookbooks
+      # NOTE: We intentionally do NOT pass options to the installer
+      self.install
     end
 
     # Get a list of all the cookbooks which have newer versions found on the community
@@ -431,7 +481,7 @@ module Berkshelf
       outdated = Hash.new
 
       sources(options).each do |cookbook|
-        location = cookbook.location || Location.init(cookbook.name, cookbook.version_constraint)
+        location = cookbook.location || Location.init(cookbook.name, cookbook.version_constraint, site: :opscode)
 
         if location.is_a?(SiteLocation)
           latest_version = location.latest_version
@@ -476,38 +526,17 @@ module Berkshelf
       options = options.reverse_merge(
         force: false,
         freeze: true,
-        ssl_verify: Berkshelf::Config.instance.ssl.verify,
         skip_dependencies: false,
         halt_on_frozen: false
       )
 
-      ridley_options               = options.slice(:ssl)
-      ridley_options[:server_url]  = options[:server_url] || Berkshelf::Config.instance.chef.chef_server_url
-      ridley_options[:client_name] = Berkshelf::Config.instance.chef.node_name
-      ridley_options[:client_key]  = Berkshelf::Config.instance.chef.client_key
-      ridley_options[:ssl]         = { verify: options[:ssl_verify] }
-
-      unless ridley_options[:server_url].present?
-        raise UploadFailure, "Missing required attribute in your Berkshelf configuration: chef.server_url"
-      end
-
-      unless ridley_options[:client_name].present?
-        raise UploadFailure, "Missing required attribute in your Berkshelf configuration: chef.node_name"
-      end
-
-      unless ridley_options[:client_key].present?
-        raise UploadFailure, "Missing required attribute in your Berkshelf configuration: chef.client_key"
-      end
-
-      solution    = resolve(options)
+      solution    = resolve(sources(options), options)[:solution]
       upload_opts = options.slice(:force, :freeze)
-      conn        = Ridley.new(ridley_options)
+      conn        = ridley_connection(options)
 
       solution.each do |cb|
         Berkshelf.formatter.upload(cb.cookbook_name, cb.version, conn.server_url)
 
-        validate_files!(cb)
-
         begin
           conn.cookbook.upload(cb.path, upload_opts.merge(name: cb.cookbook_name))
         rescue Ridley::Errors::FrozenCookbook => ex
@@ -528,27 +557,122 @@ module Berkshelf
       end
     rescue Ridley::Errors::RidleyError => ex
       log_exception(ex)
-      raise UploadFailure, ex
+      raise ChefConnectionError, ex # todo implement
     ensure
       conn.terminate if conn && conn.alive?
     end
 
+    # Resolve this Berksfile and apply the locks found in the generated Berksfile.lock to the
+    # target Chef environment
+    #
+    # @param [String] environment_name
+    #
+    # @option options [Hash] :ssl_verify (true)
+    #   Disable/Enable SSL verification during uploads
+    #
+    # @raise [EnvironmentNotFound] if the target environment was not found
+    # @raise [ChefConnectionError] if you are locking cookbooks with an invalid or not-specified client configuration
+    def apply(environment_name, options = {})
+      conn        = ridley_connection(options)
+      environment = conn.environment.find(environment_name)
+
+      if environment
+        install
+
+        environment.cookbook_versions = {}.tap do |cookbook_versions|
+          lockfile.sources.each { |source| cookbook_versions[source.name] = source.locked_version }
+        end
+
+        environment.save
+      else
+        raise EnvironmentNotFound.new(environment_name)
+      end
+    rescue Ridley::Errors::RidleyError => ex
+      raise ChefConnectionError, ex
+    ensure
+      conn.terminate if conn && conn.alive?
+    end
+
+    # Package the given cookbook for distribution outside of berkshelf. If the
+    # name attribute is not given, all cookbooks in the Berksfile will be
+    # packaged.
+    #
+    # @param [String] name
+    #   the name of the cookbook to package
+    # @param [Hash] options
+    #   a list of options
+    #
+    # @option options [String] :output
+    #   the path to output the tarball
+    # @option options [Boolean] :skip_dependencies
+    #   package cookbook dependencies as well
+    # @option options [Boolean] :ignore_chefignore
+    #   do not apply the chefignore file to the packed cookbooks
+    #
+    # @return [String]
+    #   the path to the package
+    def package(name = nil, options = {})
+      tar_name = "#{name || 'package'}.tar.gz"
+      output = File.expand_path(File.join(options[:output], tar_name))
+
+      unless name.nil?
+        source = self.find(name)
+        raise CookbookNotFound, "Cookbook '#{name}' is not in your Berksfile" unless source
+
+        package = Berkshelf.ui.mute {
+          self.resolve(source, options)[:solution]
+        }
+      else
+        package = Berkshelf.ui.mute {
+          self.resolve(sources, options)[:solution]
+        }
+      end
+
+      Dir.mktmpdir do |tmp|
+        package.each do |cached_cookbook|
+          path = cached_cookbook.path.to_s
+          destination = File.join(tmp, cached_cookbook.cookbook_name)
+
+          FileUtils.cp_r(path, destination)
+
+          unless options[:ignore_chefignore]
+            if ignore_file = Berkshelf::Chef::Cookbook::Chefignore.find_relative_to(path)
+              chefignore = Berkshelf::Chef::Cookbook::Chefignore.new(ignore_file)
+              chefignore.remove_ignores_from(destination) if chefignore
+            end
+          end
+        end
+
+        FileUtils.mkdir_p(options[:output])
+
+        Dir.chdir(tmp) do |dir|
+          tgz = Zlib::GzipWriter.new(File.open(output, 'wb'))
+          Archive::Tar::Minitar.pack('.', tgz)
+        end
+      end
+
+      Berkshelf.formatter.package(name, output)
+
+      output
+    end
+
     # Finds a solution for the Berksfile and returns an array of CachedCookbooks.
     #
-    # @option options [Symbol, Array] :except
-    #   Group(s) to exclude which will cause any sources marked as a member of the
-    #   group to not be installed
-    # @option options [Symbol, Array] :only
-    #   Group(s) to include which will cause any sources marked as a member of the
-    #   group to be installed and all others to be ignored
-    # @option cookbooks [String, Array] :cookbooks
-    #   Names of the cookbooks to retrieve sources for
+    # @param [Array<Berkshelf::CookbookSource>] sources
+    #   Array of cookbook sources to resolve
+    #
     # @option options [Boolean] :skip_dependencies
     #   Skip resolving of dependencies
     #
-    # @return [Array<Berkshelf::CachedCookbooks]
-    def resolve(options = {})
-      resolver(options).resolve
+    # @return [Array<Berkshelf::CachedCookbooks>]
+    def resolve(sources = [], options = {})
+      resolver = Resolver.new(
+        self,
+        sources: sources,
+        skip_dependencies: options[:skip_dependencies]
+      )
+
+      { solution: resolver.resolve, sources: resolver.sources }
     end
 
     # Reload this instance of Berksfile with the given content. The content
@@ -568,56 +692,100 @@ module Berkshelf
       self
     end
 
+    # Get the lockfile corresponding to this Berksfile. This is necessary because
+    # the user can specify a different path to the Berksfile. So assuming the lockfile
+    # is named "Berksfile.lock" is a poor assumption.
+    #
+    # @return [Berkshelf::Lockfile]
+    #   the lockfile corresponding to this berksfile, or a new Lockfile if one does
+    #   not exist
+    def lockfile
+      @lockfile ||= Berkshelf::Lockfile.new(self)
+    end
+
     private
 
+      def ridley_connection(options = {})
+        ridley_options               = options.slice(:ssl)
+        ridley_options[:server_url]  = options[:server_url] || Berkshelf::Config.instance.chef.chef_server_url
+        ridley_options[:client_name] = Berkshelf::Config.instance.chef.node_name
+        ridley_options[:client_key]  = Berkshelf::Config.instance.chef.client_key
+        ridley_options[:ssl]         = { verify: (options[:ssl_verify] || Berkshelf::Config.instance.ssl.verify) }
+
+        unless ridley_options[:server_url].present?
+          raise ChefConnectionError, "Missing required attribute in your Berkshelf configuration: chef.server_url"
+        end
+
+        unless ridley_options[:client_name].present?
+          raise ChefConnectionError, "Missing required attribute in your Berkshelf configuration: chef.node_name"
+        end
+
+        unless ridley_options[:client_key].present?
+          raise ChefConnectionError, "Missing required attribute in your Berkshelf configuration: chef.client_key"
+        end
+
+        Ridley.new(ridley_options)
+      end
+
       def descendant_directory?(candidate, parent)
         hack = FileUtils::Entry_.new('/tmp')
         hack.send(:descendant_diretory?, candidate, parent)
       end
 
-      def lockfile_present?
-        File.exist?(Berkshelf::Lockfile::DEFAULT_FILENAME)
-      end
-
-      # Builds a Resolver instance
+      # Determine if any cookbooks were specified that aren't in our shelf.
       #
-      # @option options [Symbol, Array] :except
-      #   Group(s) to exclude which will cause any sources marked as a member of the
-      #   group to not be installed
-      # @option options [Symbol, Array] :only
-      #   Group(s) to include which will cause any sources marked as a member of the
-      #   group to be installed and all others to be ignored
-      # @option options [String, Array] :cookbooks
-      #   Names of the cookbooks to retrieve sources for
-      # @option options [Boolean] :skip_dependencies
-      #   Skip resolving of dependencies
+      # @option options [Array<String>] :cookbooks
+      #   a list of strings of cookbook names
       #
-      # @return <Berkshelf::Resolver>
-      def resolver(options = {})
-        Resolver.new(self, sources: sources(options), skip_dependencies: options[:skip_dependencies])
+      # @raise [Berkshelf::CookbookNotFound]
+      #   if a cookbook name is given that does not exist
+      def validate_cookbook_names!(options = {})
+        missing = (Array(options[:cookbooks]) - sources.map(&:name))
+        unless missing.empty?
+          raise Berkshelf::CookbookNotFound,
+            "Could not find cookbooks #{missing.collect{ |c| "'#{c}'" }.join(', ')} " +
+            "in any of the sources. #{missing.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
+        end
       end
 
-      def write_lockfile(sources)
-        Berkshelf::Lockfile.new(sources).write
+      # The list of sources "locked" by the lockfile.
+      #
+      # @return [Array<Berkshelf::CookbookSource>]
+      #   the list of sources in this lockfile
+      def locked_sources
+        lockfile.sources
       end
 
-      def update_lockfile(sources)
-        Berkshelf::Lockfile.update!(sources)
+      # Merge the locked sources against the given sources.
+      #
+      # For each the given sources, check if there's a locked version that
+      # still satisfies the version constraint. If it does, "lock" that source
+      # because we should just use the locked version.
+      #
+      # If a locked source exists, but doesn't satisfy the constraint, raise a
+      # {Berkshelf::OutdatedCookbookSource} and tell the user to run update.
+      def apply_lockfile(sources = [])
+        sources.collect do |source|
+          source_from_lockfile(source) || source
+        end
       end
 
-      # Validate that the given cookbook does not have "bad" files. Currently
-      # this means including spaces in filenames (such as recipes)
-      #
-      # @param [Berkshelf::CachedCookbook] cookbook
-      #  the Cookbook to validate
-      def validate_files!(cookbook)
-        path = cookbook.path.to_s
+      def source_from_lockfile(source)
+        locked_source = lockfile.find(source)
+
+        return nil unless locked_source
 
-        files = Dir.glob(File.join(path, '**', '*.rb')).select do |f|
-          f =~ /[[:space:]]/
+        # If there's a locked_version, make sure it's still satisfied
+        # by the constraint
+        if locked_source.locked_version
+          unless source.version_constraint.satisfies?(locked_source.locked_version)
+            raise Berkshelf::OutdatedCookbookSource.new(locked_source, source)
+          end
         end
 
-        raise Berkshelf::InvalidCookbookFiles.new(cookbook, files) unless files.empty?
+        # Update to the new constraint (it might have changed, but still be satisfied)
+        locked_source.version_constraint = source.version_constraint
+        locked_source
       end
   end
 end