berkshelf 3.0.0.beta6 → 3.0.0.beta7

data/lib/berkshelf/formatters/json.rb

@@ -39,34 +39,30 @@ module Berkshelf
 
       # Add a Cookbook installation entry to delayed output
       #
-      # @param [String] cookbook
-      # @param [String] version
-      # @option options [String] :api_source
-      #   the berkshelf-api source url
-      # @option options [String] :location_path
-      #   the chef server url for a cookbook's location
-      def install(cookbook, version, options = {})
-        cookbooks[cookbook] ||= {}
-        cookbooks[cookbook][:version] = version
-
-        if options.has_key?(:api_source) && options.has_key?(:location_path)
-          cookbooks[cookbook][:api_source] = options[:api_source] unless options[:api_source] == Berkshelf::Berksfile::DEFAULT_API_URL
-          cookbooks[cookbook][:location_path] = options[:location_path] unless options[:api_source] == Berkshelf::Berksfile::DEFAULT_API_URL
+      # @param [Source] source
+      #   the source the dependency is being downloaded from
+      # @param [RemoteCookbook] cookbook
+      #   the cookbook to be downloaded
+      def install(source, cookbook)
+        cookbooks[cookbook.name] ||= {}
+        cookbooks[cookbook.name][:version] = cookbook.version
+
+        unless source.default?
+          cookbooks[cookbook.name][:api_source]    = source.uri
+          cookbooks[cookbook.name][:location_path] = cookbook.location_path
         end
       end
 
       # Add a Cookbook use entry to delayed output
       #
-      # @param [String] cookbook
-      # @param [String] version
-      # @param [~Location] location
-      def use(cookbook, version, location = nil)
-        cookbooks[cookbook] ||= {}
-        cookbooks[cookbook][:version] = version
-
-        if location && location.is_a?(PathLocation)
-          cookbooks[cookbook][:metadata] = true if location.metadata?
-          cookbooks[cookbook][:location] = location.relative_path
+      # @param [Dependency] dependency
+      def use(dependency)
+        cookbooks[dependency.name] ||= {}
+        cookbooks[dependency.name][:version] = dependency.cached_cookbook.version
+
+        if dependency.location.is_a?(PathLocation)
+          cookbooks[dependency.name][:metadata] = true if dependency.location.metadata?
+          cookbooks[dependency.name][:location] = dependency.location.relative_path
         end
       end
 
@@ -111,13 +107,13 @@ module Berkshelf
 
       # Output a list of cookbooks to delayed output
       #
-      # @param [Hash<Dependency, CachedCookbook>] list
-      def list(list)
-        list.each do |dependency, cookbook|
-          cookbooks[cookbook.cookbook_name] ||= {}
-          cookbooks[cookbook.cookbook_name][:version] = cookbook.version
+      # @param [Array<Dependency>] dependencies
+      def list(dependencies)
+        dependencies.each do |dependency, cookbook|
+          cookbooks[dependency.name] ||= {}
+          cookbooks[dependency.name][:version] = dependency.locked_version.to_s
           if dependency.location
-            cookbooks[cookbook.cookbook_name][:location] = dependency.location
+            cookbooks[dependency.name][:location] = dependency.location
           end
         end
       end

data/lib/berkshelf/installer.rb

@@ -2,16 +2,14 @@ require 'berkshelf/api-client'
 
 module Berkshelf
   class Installer
-    extend Forwardable
-
     attr_reader :berksfile
+    attr_reader :lockfile
     attr_reader :downloader
 
-    def_delegator :berksfile, :lockfile
-
     # @param [Berkshelf::Berksfile] berksfile
     def initialize(berksfile)
       @berksfile  = berksfile
+      @lockfile   = berksfile.lockfile
       @downloader = Downloader.new(berksfile)
     end
 
@@ -19,6 +17,7 @@ module Berkshelf
       berksfile.sources.collect do |source|
         Thread.new do
           begin
+            Berkshelf.formatter.msg("Fetching cookbook index from #{source.uri}...")
             source.build_universe
           rescue Berkshelf::APIClientError => ex
             Berkshelf.formatter.warn "Error retrieving universe from source: #{source}"
@@ -28,146 +27,136 @@ module Berkshelf
       end.map(&:join)
     end
 
-    # @option options [Array<String>, String] cookbooks
-    #
     # @return [Array<Berkshelf::CachedCookbook>]
-    def run(options = {})
-      dependencies = lockfile_reduce(berksfile.dependencies(options.slice(:except, :only)))
-      resolver     = Resolver.new(berksfile, dependencies)
-      lock_deps    = []
-
-      dependencies.each do |dependency|
-        if dependency.scm_location?
-          Berkshelf.formatter.fetch(dependency)
-          downloader.download(dependency)
-        end
-
-        next if (cookbook = dependency.cached_cookbook).nil?
+    def run
+      reduce_lockfile!
 
-        resolver.add_explicit_dependencies(cookbook)
+      cookbooks = if lockfile.trusted?
+        install_from_lockfile
+      else
+        install_from_universe
       end
 
-      Berkshelf.formatter.msg("building universe...")
-      build_universe
+      lockfile.graph.update(cookbooks)
+      lockfile.update(berksfile.dependencies)
+      lockfile.save
 
-      cached_cookbooks = resolver.resolve.collect do |name, version, dependency|
-        lock_deps << dependency
-        dependency.locked_version ||= Solve::Version.new(version)
-        if dependency.downloaded?
-          Berkshelf.formatter.use(dependency.name, dependency.cached_cookbook.version, dependency.location)
-          dependency.cached_cookbook
-        else
-          source = berksfile.sources.find { |source| source.cookbook(name, version) }
-          remote_cookbook = source.cookbook(name, version)
-          Berkshelf.formatter.install(name, version, api_source: source, location_type: remote_cookbook.location_type,
-            location_path: remote_cookbook.location_path)
-          temp_filepath = downloader.download(name, version)
-          CookbookStore.import(name, version, temp_filepath)
-        end
+      cookbooks
+    end
+
+    # Install all the dependencies from the lockfile graph.
+    #
+    # @return [Array<CachedCookbook>]
+    #   the list of installed cookbooks
+    def install_from_lockfile
+      locks = lockfile.graph.locks
+
+      # Only construct the universe if we are going to download things
+      unless locks.all? { |_, dependency| dependency.downloaded? }
+        build_universe
       end
 
-      verify_licenses!(lock_deps)
-      lockfile.update(lock_deps)
-      cached_cookbooks
+      locks.sort.collect do |name, dependency|
+        install(dependency)
+      end
     end
 
-    # Verify that the licenses of all the cached cookbooks fall in the realm of
-    # allowed licenses from the Berkshelf Config.
-    #
-    # @param [Array<Berkshelf::Dependencies>] dependencies
+    # Resolve and install the dependencies from the "universe", updating the
+    # lockfile appropiately.
     #
-    # @raise [Berkshelf::LicenseNotAllowed]
-    #   if the license is not permitted and `raise_license_exception` is true
-    def verify_licenses!(dependencies)
-      licenses = Array(Berkshelf.config.allowed_licenses)
-      return if licenses.empty?
+    # @return [Array<CachedCookbook>]
+    #   the list of installed cookbooks
+    def install_from_universe
+      dependencies = lockfile.graph.locks.values + berksfile.dependencies
+      dependencies = dependencies.inject({}) do |hash, dependency|
+        # Fancy way of ensuring no duplicate dependencies are used...
+        hash[dependency.name] ||= dependency
+        hash
+      end.values
+
+      resolver = Resolver.new(berksfile, dependencies)
+
+      # Download all SCM locations first, since they might have additional
+      # constraints that we don't yet know about
+      dependencies.select(&:scm_location?).each do |dependency|
+        Berkshelf.formatter.fetch(dependency)
+        dependency.download
+      end
+
+      # Unlike when installing from the lockfile, we _always_ need to build
+      # the universe when installing from the universe... duh
+      build_universe
 
+      # Add any explicit dependencies for already-downloaded cookbooks (like
+      # path locations)
       dependencies.each do |dependency|
-        next if dependency.location.is_a?(Berkshelf::PathLocation)
-        cached = dependency.cached_cookbook
+        if cookbook = dependency.cached_cookbook
+          resolver.add_explicit_dependencies(cookbook)
+        end
+      end
 
-        begin
-          unless licenses.include?(cached.metadata.license)
-            raise Berkshelf::LicenseNotAllowed.new(cached)
-          end
-        rescue Berkshelf::LicenseNotAllowed => e
-          if Berkshelf.config.raise_license_exception
-            FileUtils.rm_rf(cached.path)
-            raise
-          end
+      resolver.resolve.sort.collect do |dependency|
+        install(dependency)
+      end
+    end
 
-          Berkshelf.ui.warn(e.to_s)
-        end
+    # Install a specific dependency.
+    #
+    # @param [Dependency]
+    #   the dependency to install
+    # @return [CachedCookbook]
+    #   the installed cookbook
+    def install(dependency)
+      if dependency.downloaded?
+        Berkshelf.formatter.use(dependency)
+        dependency.cached_cookbook
+      else
+        name, version = dependency.name, dependency.locked_version.to_s
+        source   = berksfile.source_for(name, version)
+        cookbook = source.cookbook(name, version)
+
+        Berkshelf.formatter.install(source, cookbook)
+
+        stash = downloader.download(name, version)
+        CookbookStore.import(name, version, stash)
       end
     end
 
     private
 
-      # Returns an instance of `Berkshelf::Dependency` with an equality constraint matching
-      # the locked version of the dependency in the lockfile.
-      #
-      # If no matching dependency is found in the lockfile then nil is returned.
-      #
-      # @param [Berkshelf:Dependency] dependency
-      #
-      # @return [Berkshelf::Dependency, nil]
-      def dependency_from_lockfile(dependency)
-        locked = lockfile.find(dependency)
-
-        return nil unless locked
-
-        # If there's a locked_version, make sure it's still satisfied
-        # by the constraint
-        if locked.locked_version
-          unless dependency.version_constraint.satisfies?(locked.locked_version)
-            raise Berkshelf::OutdatedDependency.new(locked, dependency)
+    # Iterate over each top-level dependency defined in the lockfile and
+    # check if that dependency is still defined in the Berksfile.
+    #
+    # If the dependency is no longer present in the Berksfile, it is "safely"
+    # removed using {Lockfile#unlock} and {Lockfile#remove}. This prevents
+    # the lockfile from "leaking" dependencies when they have been removed
+    # from the Berksfile, but still remained locked in the lockfile.
+    #
+    # If the dependency exists, a constraint comparison is conducted to verify
+    # that the locked dependency still satisifes the original constraint. This
+    # handles the edge case where a user has updated or removed a constraint
+    # on a dependency that already existed in the lockfile.
+    #
+    # @raise [OutdatedDependency]
+    #   if the constraint exists, but is no longer satisifed by the existing
+    #   locked version
+    #
+    # @return [Array<Dependency>]
+    def reduce_lockfile!
+      lockfile.dependencies.each do |dependency|
+        if berksfile.dependencies.map(&:name).include?(dependency.name)
+          locked = lockfile.graph.find(dependency)
+          next if locked.nil?
+
+          unless dependency.version_constraint.satisfies?(locked.version)
+            raise OutdatedDependency.new(locked, dependency)
           end
+        else
+          lockfile.unlock(dependency)
         end
-
-        locked.version_constraint = Solve::Constraint.new("= #{locked.locked_version}")
-        locked
-      end
-
-      # Merge the locked dependencies against the given dependencies.
-      #
-      # For each the given dependencies, check if there's a locked version that
-      # still satisfies the version constraint. If it does, "lock" that dependency
-      # because we should just use the locked version.
-      #
-      # If a locked dependency exists, but doesn't satisfy the constraint, raise a
-      # {Berkshelf::OutdatedDependency} and tell the user to run update.
-      #
-      # Never use the locked constraint for a dependency with a {PathLocation}
-      #
-      # @param [Array<Berkshelf::Dependency>] dependencies
-      #
-      # @return [Array<Berkshelf::Dependency>]
-      def lockfile_reduce(dependencies = [])
-        {}.tap do |h|
-          (dependencies + lockfile.dependencies).each do |dependency|
-            next if h.has_key?(dependency.name)
-
-            if dependency.path_location?
-              result = dependency
-            else
-              result = dependency_from_lockfile(dependency) || dependency
-            end
-
-            h[result.name] = result
-          end
-        end.values
       end
 
-      # The list of dependencies "locked" by the lockfile.
-      #
-      # @return [Array<Berkshelf::Dependency>]
-      #   the list of dependencies in this lockfile
-      def locked_dependencies
-        lockfile.dependencies
-      end
-
-      def reduce_scm_locations(dependencies)
-        dependencies.select { |dependency| SCM_LOCATIONS.include?(dependency.class.location_key) }
-      end
+      lockfile.save
+    end
   end
 end

data/lib/berkshelf/locations/git_location.rb

@@ -68,7 +68,7 @@ module Berkshelf
 
       tmp_path = rel ? File.join(repo_path, rel) : repo_path
       unless File.chef_cookbook?(tmp_path)
-        msg = "Cookbook '#{dependency.name}' not found at git: #{to_display}"
+        msg = "Cookbook '#{dependency.name}' not found at #{to_s}"
         msg << " at path '#{rel}'" if rel
         raise CookbookNotFound, msg
       end
@@ -90,18 +90,31 @@ module Berkshelf
       end
     end
 
+    def ==(other)
+      other.is_a?(GitLocation) &&
+      other.uri == uri &&
+      other.branch == branch &&
+      other.ref == ref &&
+      other.rel == rel
+    end
+
     def to_s
-      "#{self.class.location_key}: #{to_display}"
+      if rel
+        "#{uri} (at #{branch || ref[0...7]}/#{rel})"
+      else
+        "#{uri} (at #{branch || ref[0...7]})"
+      end
     end
 
-    private
+    def to_lock
+      out =  "    git: #{uri}\n"
+      out << "    branch: #{branch}\n" if branch
+      out << "    ref: #{ref}\n"       if ref
+      out << "    rel: #{rel}\n"       if rel
+      out
+    end
 
-      def to_display
-        info = checkout_info
-        s = "'#{uri}' with #{info[:kind]}: '#{info[:rev]}'"
-        s << " at ref: '#{ref}'" if ref && (info[:kind] != "ref" || ref != info[:rev])
-        s
-      end
+    private
 
       def cached?(destination)
         revision_path(destination) && File.exists?(revision_path(destination))

data/lib/berkshelf/locations/mercurial_location.rb

@@ -49,8 +49,7 @@ module Berkshelf
 
       tmp_path = rel ? File.join(repo_path, rel) : repo_path
       unless File.chef_cookbook?(tmp_path)
-        msg = "Cookbook '#{dependency.name}' not found at hg: #{uri}"
-        msg << " with rev '#{rev}'" if rev
+        msg = "Cookbook '#{dependency.name}' not found at #{to_s}"
         msg << " at path '#{rel}'" if rel
         raise CookbookNotFound, msg
       end
@@ -72,10 +71,26 @@ module Berkshelf
       end
     end
 
+    def ==(other)
+      other.is_a?(MercurialLocation) &&
+      other.uri == uri &&
+      other.rev == rev &&
+      other.rel == rel
+    end
+
     def to_s
-      s = "#{self.class.location_key}: '#{uri}'"
-      s << " at rev: '#{rev}'" if rev
-      s
+      if rel
+        "#{uri} (at #{rev}/#{rel})"
+      else
+        "#{uri} (at #{rev})"
+      end
+    end
+
+    def to_lock
+      out =  "    hg: #{uri}\n"
+      out << "    rev: #{rev}\n" if rev
+      out << "    rel: #{rel}\n" if rel
+      out
     end
 
     private

data/lib/berkshelf/locations/path_location.rb

@@ -49,6 +49,15 @@ module Berkshelf
       "./#{new_path}"
     end
 
+    #
+    # The expanded path of this path on disk, relative to the berksfile.
+    #
+    # @return [String]
+    #
+    def expanded_path
+      relative_path(dependency.berksfile.filepath)
+    end
+
     # Valid if the path exists and is readable
     #
     # @return [Boolean]
@@ -60,14 +69,20 @@ module Berkshelf
       super.merge(value: self.path)
     end
 
-    # The string representation of this PathLocation
-    #
-    # @example
-    #   loc.to_s #=> artifact (1.4.0) at path: '/Users/Seth/Dev/artifact'
-    #
-    # @return [String]
+    def ==(other)
+      other.is_a?(PathLocation) &&
+      other.metadata? == metadata? &&
+      other.expanded_path == expanded_path
+    end
+
+    def to_lock
+      out =  "    path: #{relative_path(dependency.berksfile.filepath)}\n"
+      out << "    metadata: true\n" if metadata?
+      out
+    end
+
     def to_s
-      "#{self.class.location_key}: '#{File.expand_path(path)}'"
+      "source at #{relative_path(dependency.berksfile.filepath)}"
     end
   end
 end