berkshelf 2.0.18 → 3.0.0.beta1

data/lib/berkshelf/formatters/json.rb

@@ -6,15 +6,14 @@ module Berkshelf
       register_formatter :json
 
       def initialize
-        Berkshelf.ui.mute!
-
         @output = {
           cookbooks: Array.new,
           errors: Array.new,
           messages: Array.new
         }
         @cookbooks = Hash.new
-        super
+
+        Berkshelf.ui.mute { super }
       end
 
       def cleanup_hook
@@ -26,6 +25,13 @@ module Berkshelf
         print ::JSON.pretty_generate(output)
       end
 
+      # @param [Berkshelf::Dependency] dependency
+      def fetch(dependency)
+        cookbooks[dependency] ||= {}
+        cookbooks[dependency][:version]  = dependency.cached_cookbook.version
+        cookbooks[dependency][:location] = dependency.location
+      end
+
       # Add a Cookbook installation entry to delayed output
       #
       # @param [String] cookbook
@@ -34,7 +40,11 @@ module Berkshelf
       def install(cookbook, version, location)
         cookbooks[cookbook] ||= {}
         cookbooks[cookbook][:version] = version
-        cookbooks[cookbook][:location] = location.to_s
+
+        if location && location.is_a?(PathLocation)
+          cookbooks[cookbook][:metadata] = true if location.metadata?
+          cookbooks[cookbook][:location] = location.relative_path
+        end
       end
 
       # Add a Cookbook use entry to delayed output

data/lib/berkshelf/init_generator.rb

@@ -113,7 +113,7 @@ module Berkshelf
     private
 
       def berkshelf_config
-        Berkshelf::Config.instance
+        Berkshelf.config
       end
 
       # Read the cookbook name from the metadata.rb
@@ -135,8 +135,8 @@ module Berkshelf
       #
       # @return [nil]
       def validate_configuration
-        unless Config.instance.valid?
-          raise InvalidConfiguration.new Config.instance.errors
+        unless Berkshelf.config.valid?
+          raise InvalidConfiguration.new Berkshelf.config.errors
         end
       end
 

data/lib/berkshelf/installer.rb

@@ -0,0 +1,136 @@
+module Berkshelf
+  class Installer
+    extend Forwardable
+
+    attr_reader :berksfile
+    attr_reader :downloader
+
+    def_delegator :berksfile, :lockfile
+
+    # @param [Berkshelf::Berksfile] berksfile
+    def initialize(berksfile)
+      @berksfile  = berksfile
+      @downloader = Downloader.new(berksfile)
+    end
+
+    def build_universe
+      berksfile.sources.map(&:universe)
+    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)
+
+      dependencies.each do |dependency|
+        next unless dependency.scm_location?
+        Berkshelf.formatter.fetch(dependency)
+        downloader.download(dependency)
+      end
+
+      dependencies.each do |dependency|
+        next unless dependency.cached_cookbook
+        resolver.add_explicit_dependencies(dependency)
+      end
+
+      Berkshelf.formatter.msg("building universe...")
+      build_universe
+
+      lock_deps = []
+
+      cached_cookbooks = resolver.resolve.collect do |name, version, dependency|
+        lock_deps << dependency
+        if dependency.downloaded?
+          Berkshelf.formatter.use(dependency.name, dependency.cached_cookbook.version, dependency.location)
+          dependency.cached_cookbook
+        else
+          Berkshelf.formatter.install(name, version, dependency)
+          temp_filepath = downloader.download(name, version)
+          CookbookStore.import(name, version, temp_filepath)
+        end
+      end
+
+      verify_licenses!(lock_deps)
+      lockfile.update(lock_deps)
+      cached_cookbooks
+    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
+    #
+    # @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?
+
+      dependencies.each do |dependency|
+        next if dependency.location.is_a?(Berkshelf::PathLocation)
+        cached = dependency.cached_cookbook
+
+        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
+
+          Berkshelf.ui.warn(e.to_s)
+        end
+      end
+    end
+
+    private
+
+      def dependency_from_lockfile(dependency)
+        locked_dependency = lockfile.find(dependency)
+
+        return nil unless locked_dependency
+
+        # If there's a locked_version, make sure it's still satisfied
+        # by the constraint
+        if locked_dependency.locked_version
+          unless dependency.version_constraint.satisfies?(locked_dependency.locked_version)
+            raise Berkshelf::OutdatedDependency.new(locked_dependency, dependency)
+          end
+        end
+
+        # Update to the new constraint (it might have changed, but still be satisfied)
+        locked_dependency.version_constraint = dependency.version_constraint
+        locked_dependency
+      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.
+      def lockfile_reduce(dependencies = [])
+        dependencies.collect do |dependency|
+          dependency_from_lockfile(dependency) || dependency
+        end
+      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
+  end
+end

data/lib/berkshelf/location.rb

@@ -1,75 +1,12 @@
 module Berkshelf
   module Location
-    OPSCODE_COMMUNITY_API = 'http://cookbooks.opscode.com/api/v1/cookbooks'.freeze
-
-    module ClassMethods
-      require_relative 'cookbook_source'
-
-      # Returns the location identifier key for the class
-      #
-      # @return [Symbol]
-      attr_reader :location_key
-
-      # Register the location key for the including source location with CookbookSource
-      #
-      # @param [Symbol] key
-      def set_location_key(key)
-        CookbookSource.add_location_key(key, self)
-        @location_key = key
-      end
-
-      # Register a valid option or multiple options with the CookbookSource class
-      #
-      # @param [Symbol] opts
-      def set_valid_options(*opts)
-        Array(opts).each do |opt|
-          CookbookSource.add_valid_option(opt)
-        end
-      end
-
-      # Returns an array where the first element is string representing the best version
-      # for the given constraint and the second element is the URI to where the corresponding
-      # version of the Cookbook can be downloaded from
-      #
-      # @example:
-      #   constraint = Solve::Constraint.new('~> 0.101.2')
-      #   versions = {
-      #     '1.0.0' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/1_0_0',
-      #     '2.0.0' => 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/2_0_0'
-      #   }
-      #
-      #   subject.solve_for_constraint(versions, constraint) =>
-      #     [ '2.0.0', 'http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/2_0_0' ]
-      #
-      # @param [String, Solve::Constraint] constraint
-      #   version constraint to solve for
-      #
-      # @param [Hash] versions
-      #   a hash where the keys are a string representing a cookbook version and the values
-      #   are the download URL for the cookbook version.
-      #
-      # @return [Array, nil]
-      def solve_for_constraint(constraint, versions)
-        version = Solve::Solver.satisfy_best(constraint, versions.keys).to_s
-
-        [ version, versions[version] ]
-      rescue Solve::Errors::NoSolutionError
-        nil
-      end
-    end
-
     class << self
-      def included(base)
-        base.send :extend, ClassMethods
-      end
-
       # Creates a new instance of a Class implementing Location with the given name and
       # constraint. Which Class to instantiated is determined by the values in the given
       # options Hash. Source Locations have an associated location_key registered with
-      # CookbookSource. If your options Hash contains a key matching one of these location_keys
+      # Berkshelf::Dependency. If your options Hash contains a key matching one of these location_keys
       # then the Class who registered that location_key will be instantiated. If you do not
-      # provide an option with a matching location_key a SiteLocation class will be
-      # instantiated.
+      # provide an option with a matching location_key nil will be returned.
       #
       # @example
       #   Location.init('nginx', '>= 0.0.0', git: 'git://github.com/RiotGames/artifact-cookbook.git') =>
@@ -78,97 +15,120 @@ module Berkshelf
       #   Location.init('nginx', '>= 0.0.0', path: '/Users/reset/code/nginx-cookbook') =>
       #     instantiates a PathLocation
       #
-      #   Location.init('nginx', '>= 0.0.0', site: 'http://cookbooks.opscode.com/api/v1/cookbooks') =>
-      #     instantiates a SiteLocation
-      #
-      #   Location.init('nginx', '>= 0.0.0', chef_api: 'https://api.opscode.com/organizations/vialstudios') =>
-      #     instantiates a ChefAPILocation
-      #
-      #   Location.init('nginx', '>= 0.0.0') =>
-      #     instantiates a SiteLocation
-      #
-      # @param [String] name
-      # @param [String, Solve::Constraint] constraint
+      # @param [Dependency] dependency
       # @param [Hash] options
       #
-      # @return [SiteLocation, PathLocation, GitLocation, ChefAPILocation]
-      def init(name, constraint, options = {})
-        klass = klass_from_options(options)
-
-        klass.new(name, constraint, options)
+      # @return [~Location::Base, nil]
+      def init(dependency, options = {})
+        if klass = klass_from_options(options)
+          klass.new(dependency, options)
+        end
       end
 
       private
 
         def klass_from_options(options)
-          location_keys = (options.keys & CookbookSource.location_keys.keys)
+          location_keys = (options.keys & Berkshelf::Dependency.location_keys.keys)
           if location_keys.length > 1
             location_keys.collect! { |opt| "'#{opt}'" }
-            raise InternalError, "Only one location key (#{CookbookSource.location_keys.keys.join(', ')}) may be specified. You gave #{location_keys.join(', ')}."
+            raise InternalError, "Only one location key (#{Berkshelf::Dependency.location_keys.keys.join(', ')}) " +
+              "may be specified. You gave #{location_keys.join(', ')}."
           end
 
-          if location_keys.empty?
-            SiteLocation
-          else
-            CookbookSource.location_keys[location_keys.first]
+          if location_key = location_keys.first
+            Berkshelf::Dependency.location_keys[location_key]
           end
         end
     end
 
-    attr_reader :name
-    attr_reader :version_constraint
+    class Base
+      class << self
+        # Returns the location identifier key for the class
+        #
+        # @return [Symbol]
+        attr_reader :location_key
+
+        # Register the location key for the including source location with Berkshelf::Dependency
+        #
+        # @param [Symbol] key
+        def set_location_key(key)
+          Berkshelf::Dependency.add_location_key(key, self)
+          @location_key = key
+        end
 
-    # @param [#to_s] name
-    # @param [Solve::Constraint] version_constraint
-    # @param [Hash] options
-    def initialize(name, version_constraint, options = {})
-      @name               = name
-      @version_constraint = version_constraint
-      @downloaded_status  = false
-    end
+        # Register a valid option or multiple options with the Berkshelf::Dependency class
+        #
+        # @param [Symbol] opts
+        def set_valid_options(*opts)
+          Array(opts).each do |opt|
+            Berkshelf::Dependency.add_valid_option(opt)
+          end
+        end
+      end
 
-    # @param [#to_s] destination
-    #
-    # @return [Berkshelf::CachedCookbook]
-    def download(destination)
-      raise AbstractFunction
-    end
+      extend Forwardable
+
+      attr_reader :dependency
+      def_delegator :dependency, :name
 
-    # Ensure the retrieved CachedCookbook is valid
-    #
-    # @param [CachedCookbook] cached_cookbook
-    #   the downloaded cookbook to validate
-    #
-    # @raise [CookbookValidationFailure] if given CachedCookbook does not satisfy the constraint of the location
-    #
-    # @todo Change MismatchedCookbookName to raise instead of warn
-    #
-    # @return [Boolean]
-    def validate_cached(cached_cookbook)
-      unless version_constraint.satisfies?(cached_cookbook.version)
-        raise CookbookValidationFailure.new(self, cached_cookbook)
+      # @param [Berkshelf::Dependency] dependency
+      # @param [Hash] options
+      def initialize(dependency, options = {})
+        @dependency       = dependency
+        @@cached_cookbook = nil
       end
 
-      unless self.name == cached_cookbook.cookbook_name
-        Berkshelf.ui.warn(MismatchedCookbookName.new(self, cached_cookbook).to_s)
+      # @param [#to_s] destination
+      #
+      # @return [Berkshelf::CachedCookbook]
+      def download
+        return @cached_cookbook if @cached_cookbook
+
+        cached_cookbook = do_download
+        validate_cached(cached_cookbook)
+        @cached_cookbook = cached_cookbook
       end
 
-      true
-    end
+      # @param [#to_s] destination
+      #
+      # @return [Berkshelf::CachedCookbook]
+      def do_download
+        raise AbstractFunction
+      end
 
-    def to_hash
-      {
-        type: self.class.location_key
-      }
-    end
+      # Ensure the retrieved CachedCookbook is valid
+      #
+      # @param [CachedCookbook] cached_cookbook
+      #   the downloaded cookbook to validate
+      #
+      # @raise [CookbookValidationFailure] if given CachedCookbook does not satisfy the constraint of the location
+      #
+      # @todo Change MismatchedCookbookName to raise instead of warn
+      #
+      # @return [Boolean]
+      def validate_cached(cached_cookbook)
+        unless dependency.version_constraint.satisfies?(cached_cookbook.version)
+          raise CookbookValidationFailure.new(dependency, cached_cookbook)
+        end
+
+        unless dependency.name == cached_cookbook.cookbook_name
+          Berkshelf.ui.warn(MismatchedCookbookName.new(dependency, cached_cookbook).to_s)
+        end
 
-    def to_json(options = {})
-      JSON.pretty_generate(to_hash, options)
+        true
+      end
+
+      def to_hash
+        { type: self.class.location_key }
+      end
+
+      def to_json(options = {})
+        JSON.pretty_generate(to_hash, options)
+      end
     end
   end
 end
 
-require_relative 'locations/chef_api_location'
-require_relative 'locations/git_location'
-require_relative 'locations/github_location'
-require_relative 'locations/site_location'
+Dir["#{File.dirname(__FILE__)}/locations/*.rb"].sort.each do |path|
+  require_relative "locations/#{File.basename(path, '.rb')}"
+end