berkshelf 2.0.18 → 3.0.0.beta1

data/lib/berkshelf/downloader.rb

@@ -1,129 +1,72 @@
 module Berkshelf
   class Downloader
-    require_relative 'cookbook_source'
-    require_relative 'location'
-
     extend Forwardable
 
-    DEFAULT_LOCATIONS = [
-      {
-        type: :site,
-        value: Location::OPSCODE_COMMUNITY_API,
-        options: Hash.new
-      }
-    ]
-
-    # @return [String]
-    #   a filepath to download cookbook sources to
-    attr_reader :cookbook_store
-
-    def_delegators :@cookbook_store, :storage_path
+    attr_reader :berksfile
 
-    # @option options [Array<Hash>] locations
-    def initialize(cookbook_store, options = {})
-      @cookbook_store = cookbook_store
-      @locations = options.fetch(:locations, Array.new)
-    end
+    def_delegators :berksfile, :sources
 
-    # @return [Array<Hash>]
-    #   an Array of Hashes representing each default location that can be used to attempt
-    #   to download cookbook sources which do not have an explicit location. An array of default locations will
-    #   be used if no locations are explicitly added by the {#add_location} function.
-    def locations
-      @locations.any? ? @locations : DEFAULT_LOCATIONS
+    # @param [Berkshelf::Berksfile] berksfile
+    def initialize(berksfile)
+      @berksfile = berksfile
     end
 
-    # Create a location hash and add it to the end of the array of locations.
-    #
-    # subject.add_location(:chef_api, "http://chef:8080", node_name: "reset", client_key: "/Users/reset/.chef/reset.pem") =>
-    #   [ { type: :chef_api, value: "http://chef:8080/", node_name: "reset", client_key: "/Users/reset/.chef/reset.pem" } ]
+    # Download the given Berkshelf::Dependency.
     #
-    # @param [Symbol] type
-    # @param [String, Symbol] value
-    # @param [Hash] options
+    # @param [String] name
+    # @param [String] version
     #
-    # @return [Hash]
-    def add_location(type, value, options = {})
-      if has_location?(type, value)
-        raise DuplicateLocationDefined,
-          "A default '#{type}' location with the value '#{value}' is already defined"
-      end
-
-      @locations.push(type: type, value: value, options: options)
-    end
-
-    # Checks the list of default locations if a location of the given type and value has already
-    # been added and returns true or false.
+    # @option options [String] :path
     #
-    # @return [Boolean]
-    def has_location?(type, value)
-      @locations.select { |loc| loc[:type] == type && loc[:value] == value }.any?
-    end
-
-    # Download the given CookbookSource.
+    # @raise [CookbookNotFound]
     #
-    # @param [CookbookSource] source
-    #   the source to download
-    #
-    # @return [Array]
-    #   an array containing the downloaded CachedCookbook and the Location used
-    #   to download the cookbook
-    def download(source)
-      if source.location
-        begin
-          location = source.location
-          cached   = download_location(source, location, true)
-          source.cached_cookbook = cached
+    # @return [String]
+    def download(*args)
+      options = args.last.is_a?(Hash) ? args.pop : Hash.new
+      dependency, version = args
 
-          return [cached, location]
-        rescue => e
-          raise if e.kind_of?(GitNotFound)
-          raise if e.kind_of?(CookbookValidationFailure)
-          Berkshelf.formatter.error "Failed to download '#{source.name}' from #{source.location}"
-        end
+      if dependency.is_a?(Berkshelf::Dependency)
+        dependency.download
       else
-        locations.each do |loc|
-          options = loc[:options].merge(loc[:type] => loc[:value])
-          location = Location.init(source.name, source.version_constraint, options)
-
-          cached = download_location(source, location)
-          if cached
-            source.cached_cookbook = cached
-            return [cached, location]
+        sources.each do |source|
+          if result = try_download(source, dependency, version)
+            return result
           end
         end
-      end
 
-      raise CookbookNotFound, "Cookbook '#{source.name}' not found in any of the default locations"
+        raise CookbookNotFound, "#{dependency} (#{version}) not found in any sources"
+      end
     end
 
-    private
+    # @param [Berkshelf::Source] source
+    # @param [String] name
+    # @param [String] version
+    #
+    # @return [String]
+    def try_download(source, name, version)
+      unless remote_cookbook = source.cookbook(name, version)
+        return nil
+      end
 
-      # Attempt to download the the given source from the given location, #
-      # raising an error if `raise_if_not_found` is specified.
-      #
-      # @raise [Bershelf::CookbookNotFound]
-      #   if `raise_if_not_found` is true and the source could not be
-      #   downloaded
-      #
-      # @param [Berkshelf::CookbookSource] source
-      #   the source to download
-      # @param [~Berkshelf::Location] location
-      #   the location to download from
-      # @param [Boolean] raise_if_not_found
-      #   raise a {Berkshelf::CookbookNotFound} error if true, otherwise,
-      #   return nil
-      #
-      # @return [Berkshelf::CachedCookbook, nil]
-      #   the downloaded cached cookbook, or nil if one was not found
-      def download_location(source, location, raise_if_not_found = false)
-        location.download(storage_path)
-      rescue Berkshelf::GitNotFound
-        raise
-        nil
-      rescue Berkshelf::CookbookNotFound
-        raise if raise_if_not_found
-        nil
+      case remote_cookbook.location_type
+      when :opscode
+        CommunityREST.new(remote_cookbook.location_path).download(name, version)
+      when :chef_server
+        # @todo Dynamically get credentials for remote_cookbook.location_path
+        credentials = {
+          server_url: remote_cookbook.location_path,
+          client_name: Berkshelf::Config.instance.chef.node_name,
+          client_key: Berkshelf::Config.instance.chef.client_key,
+          ssl: {
+            verify: Berkshelf::Config.instance.ssl.verify
+          }
+        }
+        Ridley.open(credentials) { |r| r.cookbook.download(name, version) }
+      else
+        raise RuntimeError, "unknown location type #{remote_cookbook.location_type}"
       end
+    rescue CookbookNotFound
+      nil
+    end
   end
 end

data/lib/berkshelf/errors.rb

@@ -11,6 +11,7 @@ module Berkshelf
     alias_method :message, :to_s
   end
 
+  class DeprecatedError < BerkshelfError; status_code(10); end
   class InternalError < BerkshelfError; status_code(99); end
   class ArgumentError < InternalError; end
   class AbstractFunction < InternalError
@@ -19,20 +20,7 @@ module Berkshelf
     end
   end
 
-  class BerksfileNotFound < BerkshelfError
-    status_code(100)
-
-    # @param [#to_s] filepath
-    #   the path where a Berksfile was not found
-    def initialize(filepath)
-      @filepath = File.dirname(File.expand_path(filepath)) rescue filepath
-    end
-
-    def to_s
-      "No Berksfile or Berksfile.lock found at '#{@filepath}'!"
-    end
-  end
-
+  class BerksfileNotFound < BerkshelfError; status_code(100); end
   class NoVersionForConstraints < BerkshelfError; status_code(101); end
   class DuplicateLocationDefined < BerkshelfError; status_code(102); end
   class CookbookNotFound < BerkshelfError; status_code(103); end
@@ -93,8 +81,23 @@ module Berkshelf
     end
   end
 
-  class DuplicateSourceDefined < BerkshelfError; status_code(105); end
-  class NoSolution < BerkshelfError; status_code(106); end
+  class DuplicateDependencyDefined < BerkshelfError; status_code(105); end
+
+  class NoSolutionError < BerkshelfError
+    status_code(106)
+
+    attr_reader :demands
+
+    # @param [Array<Berkshelf::Dependency>] demands
+    def initialize(demands)
+      @demands = demands
+    end
+
+    def to_s
+      "Unable to find a solution for demands: #{demands.join(', ')}"
+    end
+  end
+
   class CookbookSyntaxError < BerkshelfError; status_code(107); end
 
   class InvalidGitURI < BerkshelfError
@@ -132,8 +135,9 @@ module Berkshelf
   end
 
   class ConstraintNotSatisfied < BerkshelfError; status_code(111); end
-  class InvalidChefAPILocation < BerkshelfError; status_code(112); end
   class BerksfileReadError < BerkshelfError
+    status_code(113)
+
     # @param [#status_code] original_error
     def initialize(original_error)
       @original_error  = original_error
@@ -141,7 +145,6 @@ module Berkshelf
       @error_backtrace = original_error.backtrace
     end
 
-    status_code(113)
 
     def status_code
       @original_error.respond_to?(:status_code) ? @original_error.status_code : 113
@@ -164,12 +167,12 @@ module Berkshelf
   class MismatchedCookbookName < BerkshelfError
     status_code(114)
 
-    # @param [Berkshelf::Location] location
-    #   the location that is mismatched
+    # @param [Berkshelf::Dependency] dependency
+    #   the dependency with the expected name
     # @param [Berkshelf::CachedCookbook] cached_cookbook
-    #   the cached_cookbook that is mismatched
-    def initialize(location, cached_cookbook)
-      @location = location
+    #   the cached_cookbook with the mismatched name
+    def initialize(dependency, cached_cookbook)
+      @dependency      = dependency
       @cached_cookbook = cached_cookbook
     end
 
@@ -177,7 +180,7 @@ module Berkshelf
       [
         "In your Berksfile, you have:",
         "",
-        "  cookbook '#{@location.name}'",
+        "  cookbook '#{@dependency.name}'",
         "",
         "But that cookbook is actually named '#{@cached_cookbook.cookbook_name}'",
         "",
@@ -206,7 +209,7 @@ module Berkshelf
   class ConfigExists < BerkshelfError; status_code(116); end
   class ConfigurationError < BerkshelfError; status_code(117); end
   class InsufficientPrivledges < BerkshelfError; status_code(119); end
-  class ExplicitCookbookNotFound < BerkshelfError; status_code(120); end
+  class DependencyNotFound < BerkshelfError; status_code(120); end
   class ValidationFailed < BerkshelfError; status_code(121); end
   class InvalidVersionConstraint < BerkshelfError; status_code(122); end
   class CommunitySiteError < BerkshelfError; status_code(123); end
@@ -218,21 +221,13 @@ module Berkshelf
     #   the location (or any subclass) raising this validation error
     # @param [Berkshelf::CachedCookbook] cached_cookbook
     #   the cached_cookbook that does not satisfy the constraint
-    def initialize(location, cached_cookbook)
-      @location = location
+    def initialize(dependency, cached_cookbook)
+      @dependency      = dependency
       @cached_cookbook = cached_cookbook
     end
 
     def to_s
-      [
-        "The cookbook downloaded from #{@location.to_s}:",
-        "  #{@cached_cookbook.cookbook_name} (#{@cached_cookbook.version})",
-        "",
-        "does not satisfy the version constraint:",
-        "  #{@cached_cookbook.cookbook_name} (#{@location.version_constraint})",
-        "",
-        "This occurs when the Chef Server has a cookbook with a missing/mis-matched version number in its `metadata.rb`",
-      ].join("\n")
+      "The cookbook downloaded for #{@dependency} did not satisfy the constraint."
     end
   end
 
@@ -240,45 +235,27 @@ module Berkshelf
 
   class UploadFailure < BerkshelfError; end
   class FrozenCookbook < UploadFailure; status_code(126); end
-  class InvalidSiteShortnameError < BerkshelfError
-    status_code(127)
 
-    # @param [String,Symbol] shortname
-    #   the shortname for the site (see SiteLocation::SHORTNAMES)
-    def initialize(shortname)
-      @shortname = shortname
-    end
-
-    def to_s
-      [
-        "Unknown site shortname '#{@shortname}' - supported shortnames are:",
-        "",
-        "  * " + SiteLocation::SHORTNAMES.keys.join("\n  * "),
-      ].join("\n")
-    end
-  end
-
-  class OutdatedCookbookSource < BerkshelfError
+  class OutdatedDependency < BerkshelfError
     status_code(128)
 
-    # @param [Berkshelf::CookbookSource] source
-    #   the cookbook source that is outdated
-    def initialize(locked_source, source)
-      @locked_source = locked_source
-      @source = source
+    # @param [Berkshelf::Dependency] locked_dependency
+    #   the locked dependency
+    # @param [Berkshelf::Dependency] dependency
+    #   the dependency that is outdated
+    def initialize(locked_dependency, dependency)
+      @locked_dependency = locked_dependency
+      @dependency        = dependency
     end
 
     def to_s
-      [
-        "Berkshelf could not find compatible versions for cookbook '#{@source.name}':",
-        "  In Berksfile:",
-        "    #{@source.name} (#{@source.version_constraint})",
-        "",
-        "  In Berksfile.lock:",
-        "    #{@locked_source.name} (#{@locked_source.locked_version})",
-        "",
-        "Try running `berks update #{@source.name}, which will try to find  '#{@source.name}' matching '#{@source.version_constraint}'.",
-      ].join("\n")
+      "Berkshelf could not find compatible versions for cookbook '#{@dependency.name}':\n" +
+      "  In Berksfile:\n" +
+      "    #{@dependency.name} (#{@dependency.version_constraint})\n\n" +
+      "  In Berksfile.lock:\n" +
+      "    #{@locked_dependency.name} (#{@locked_dependency.locked_version})\n\n" +
+      "Try running `berks update #{@dependency.name}, which will try to find '#{@dependency.name}' matching " +
+        "'#{@dependency.version_constraint}'."
     end
   end
 
@@ -294,8 +271,6 @@ module Berkshelf
     end
   end
 
-  class EnvironmentFileNotFound < BerkshelfError; status_code(137); end
-
   class ChefConnectionError < BerkshelfError
     status_code(130)
 
@@ -411,4 +386,22 @@ module Berkshelf
       "Error reading the Berkshelf lockfile `#{@lockfile}` (#{@original.class})"
     end
   end
+
+  class InvalidSourceURI < BerkshelfError
+    status_code(137)
+
+    attr_reader :reason
+
+    def initialize(url, reason = nil)
+      @url    = url
+      @reason = reason
+    end
+
+    def to_s
+      msg = "'#{@url}' is not a valid Berkshelf source URI."
+      msg + " #{reason}." unless reason.nil?
+    end
+  end
+
+  class DuplicateDemand < BerkshelfError; status_code(138); end
 end

data/lib/berkshelf/formatters.rb

@@ -50,8 +50,6 @@ module Berkshelf
     #
     #   Implement {#cleanup_hook} to run any steps required to run after the task is finished
     module AbstractFormatter
-      extend ActiveSupport::Concern
-
       module ClassMethods
         # @param [Symbol] id
         #
@@ -66,18 +64,22 @@ module Berkshelf
       end
 
       class << self
+        def included(base)
+          base.send(:extend, ClassMethods)
+        end
+
         private
 
-        def formatter_methods(*args)
-          args.each do |meth|
-            define_method(meth.to_sym) do |*args|
-              raise AbstractFunction, "##{meth} must be implemented on #{self.class}"
-            end unless respond_to?(meth.to_sym)
+          def formatter_methods(*args)
+            args.each do |meth|
+              define_method(meth.to_sym) do |*args|
+                raise AbstractFunction, "##{meth} must be implemented on #{self.class}"
+              end unless respond_to?(meth.to_sym)
+            end
           end
-        end
       end
 
-      formatter_methods :install, :use, :upload, :msg, :error, :package, :show
+      formatter_methods :fetch, :install, :use, :upload, :msg, :error, :package, :show
 
       def cleanup_hook
         # run after the task is finished

data/lib/berkshelf/formatters/human_readable.rb

@@ -5,13 +5,18 @@ module Berkshelf
 
       register_formatter :human
 
+      # @param [Berkshelf::Dependency] dependency
+      def fetch(dependency)
+        Berkshelf.ui.info "Fetching '#{dependency.name}' from #{dependency.location}"
+      end
+
       # Output a Cookbook installation message using {Berkshelf.ui}
       #
       # @param [String] cookbook
       # @param [String] version
-      # @param [~Location] location
-      def install(cookbook, version, location)
-        Berkshelf.ui.info "Installing #{cookbook} (#{version}) from #{location}"
+      # @param [Berkshelf::Dependency] dependency
+      def install(cookbook, version, dependency)
+        Berkshelf.ui.info "Installing #{cookbook} (#{version})"
       end
 
       # Output a Cookbook use message using {Berkshelf.ui}
@@ -21,12 +26,7 @@ module Berkshelf
       # @param [~Location] location
       def use(cookbook, version, location = nil)
         message = "Using #{cookbook} (#{version})"
-
-        if location.is_a?(PathLocation)
-          message << ' from metadata' if location.metadata?
-          message << " at '#{location.relative_path}'" unless location.relative_path == '.'
-        end
-
+        message += " #{location}" if location
         Berkshelf.ui.info message
       end