berkshelf 5.2.0 → 8.0.15

data/lib/berkshelf/installer.rb

@@ -1,4 +1,6 @@
-require 'berkshelf/api-client'
+require_relative "api-client"
+require "concurrent/executors"
+require "concurrent/future"
 
 module Berkshelf
   class Installer
@@ -10,19 +12,20 @@ module Berkshelf
     def initialize(berksfile)
       @berksfile  = berksfile
       @lockfile   = berksfile.lockfile
-      @worker     = Worker.pool(size: [(Celluloid.cores.to_i - 1), 2].max, args: [berksfile])
+      @pool       = Concurrent::FixedThreadPool.new([Concurrent.processor_count - 1, 2].max)
+      @worker     = Worker.new(berksfile)
     end
 
     def build_universe
       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}"
-            Berkshelf.formatter.warn "  * [#{ex.class}] #{ex}"
-          end
+
+          Berkshelf.formatter.msg("Fetching cookbook index from #{source}...")
+          source.build_universe
+        rescue Berkshelf::APIClientError => ex
+          Berkshelf.formatter.warn "Error retrieving universe from source: #{source}"
+          Berkshelf.formatter.warn "  * [#{ex.class}] #{ex}"
+
         end
       end.map(&:join)
     end
@@ -31,13 +34,14 @@ module Berkshelf
     def run
       lockfile.reduce!
 
-      Berkshelf.formatter.msg('Resolving cookbook dependencies...')
+      Berkshelf.formatter.msg("Resolving cookbook dependencies...")
 
-      dependencies, cookbooks = if lockfile.trusted?
-        install_from_lockfile
-      else
-        install_from_universe
-      end
+      dependencies, cookbooks =
+        if lockfile.trusted?
+          install_from_lockfile
+        else
+          install_from_universe
+        end
 
       Berkshelf.log.debug "  Finished resolving, calculating locks"
 
@@ -59,131 +63,136 @@ module Berkshelf
 
     private
 
-      attr_reader :worker
-
-      class Worker
-        include Celluloid
+    attr_reader :worker
+    attr_reader :pool
 
-        attr_reader :berksfile
-        attr_reader :downloader
+    class Worker
+      attr_reader :berksfile
+      attr_reader :downloader
 
-        def initialize(berksfile)
-          @berksfile  = berksfile
-          @downloader = Downloader.new(berksfile)
-        end
+      def initialize(berksfile)
+        @berksfile  = berksfile
+        @downloader = Downloader.new(berksfile)
+      end
 
-        # Install a specific dependency.
-        #
-        # @param [Dependency]
-        #   the dependency to install
-        # @return [CachedCookbook]
-        #   the installed cookbook
-        def install(dependency)
-          Berkshelf.log.info "Installing #{dependency}"
+      # Install a specific dependency.
+      #
+      # @param [Dependency]
+      #   the dependency to install
+      # @return [CachedCookbook]
+      #   the installed cookbook
+      def install(dependency)
+        Berkshelf.log.info "Installing #{dependency}"
 
-          if dependency.installed?
-            Berkshelf.log.debug "  Already installed - skipping install"
+        if dependency.installed?
+          Berkshelf.log.debug "  Already installed - skipping install"
 
-            Berkshelf.formatter.use(dependency)
-            dependency.cached_cookbook
-          else
-            name, version = dependency.name, dependency.locked_version.to_s
-            source = berksfile.source_for(name, version)
+          Berkshelf.formatter.use(dependency)
+          dependency.cached_cookbook
+        else
+          name, version = dependency.name, dependency.locked_version.to_s
+          source = berksfile.source_for(name, version)
 
-            # Raise error if our Berksfile.lock has cookbook versions that
-            # can't be found in sources
-            raise MissingLockfileCookbookVersion.new(name, version, 'in any of the sources') unless source
+          # Raise error if our Berksfile.lock has cookbook versions that
+          # can't be found in sources
+          raise MissingLockfileCookbookVersion.new(name, version, "in any of the sources") unless source
 
-            Berkshelf.log.debug "  Downloading #{dependency.name} (#{dependency.locked_version}) from #{source}"
+          Berkshelf.log.debug "  Downloading #{dependency.name} (#{dependency.locked_version}) from #{source}"
 
-            cookbook = source.cookbook(name, version)
+          cookbook = source.cookbook(name, version)
 
-            Berkshelf.log.debug "    => #{cookbook.inspect}"
+          Berkshelf.log.debug "    => #{cookbook.inspect}"
 
-            Berkshelf.formatter.install(source, cookbook)
+          Berkshelf.formatter.install(source, cookbook)
 
-            downloader.download(name, version) do |stash|
-              CookbookStore.import(name, version, stash)
-            end
+          downloader.download(name, version) do |stash|
+            CookbookStore.import(name, version, stash)
           end
         end
       end
+    end
 
-      # Install all the dependencies from the lockfile graph.
-      #
-      # @return [Array<Array<Dependency> Array<CachedCookbook>>]
-      #   the list of installed dependencies and cookbooks
-      def install_from_lockfile
-        Berkshelf.log.info "Installing from lockfile"
-
-        dependencies = lockfile.graph.locks.values
-
-        Berkshelf.log.debug "  Dependencies"
-        dependencies.map do |dependency|
-          Berkshelf.log.debug "    #{dependency}"
-        end
-
-        download_locations(dependencies)
-
-        # Only construct the universe if we are going to install things
-        unless dependencies.all?(&:installed?)
-          Berkshelf.log.debug "  Not all dependencies are installed"
-          build_universe
-        end
+    # Install all the dependencies from the lockfile graph.
+    #
+    # @return [Array<Array<Dependency> Array<CachedCookbook>>]
+    #   the list of installed dependencies and cookbooks
+    def install_from_lockfile
+      Berkshelf.log.info "Installing from lockfile"
 
-        cookbooks = dependencies.sort.map { |dependency| worker.future.install(dependency) }.map(&:value)
+      dependencies = lockfile.graph.locks.values
 
-        [dependencies, cookbooks]
+      Berkshelf.log.debug "  Dependencies"
+      dependencies.map do |dependency|
+        Berkshelf.log.debug "    #{dependency}"
       end
 
-      # Resolve and install the dependencies from the "universe", updating the
-      # lockfile appropiately.
-      #
-      # @return [Array<Array<Dependency> Array<CachedCookbook>>]
-      #   the list of installed dependencies and cookbooks
-      def install_from_universe
-        Berkshelf.log.info "Installing 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
+      download_locations(dependencies)
 
-        download_locations(dependencies)
+      # Only construct the universe if we are going to install things
+      unless dependencies.all?(&:installed?)
+        Berkshelf.log.debug "  Not all dependencies are installed"
+        build_universe
+      end
 
-        Berkshelf.log.debug "  Creating a resolver"
-        resolver = Resolver.new(berksfile, dependencies)
+      futures = dependencies.sort.map { |dependency| Concurrent::Future.execute(executor: pool) { worker.install(dependency) } }
+      cookbooks = futures.map(&:value)
+      rejects = futures.select(&:rejected?)
+      raise rejects.first.reason unless rejects.empty?
 
-        # Unlike when installing from the lockfile, we _always_ need to build
-        # the universe when installing from the universe... duh
-        build_universe
+      [dependencies, cookbooks]
+    end
 
-        # Add any explicit dependencies for already-downloaded cookbooks (like
-        # path locations)
-        dependencies.each do |dependency|
-          if dependency.location
-            cookbook = dependency.cached_cookbook
-            Berkshelf.log.debug "  Adding explicit dependency on #{cookbook}"
-            resolver.add_explicit_dependencies(cookbook)
-          end
+    # Resolve and install the dependencies from the "universe", updating the
+    # lockfile appropiately.
+    #
+    # @return [Array<Array<Dependency> Array<CachedCookbook>>]
+    #   the list of installed dependencies and cookbooks
+    def install_from_universe
+      Berkshelf.log.info "Installing 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
+
+      download_locations(dependencies)
+
+      Berkshelf.log.debug "  Creating a resolver"
+      resolver = Resolver.new(berksfile, dependencies)
+
+      # 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|
+        if dependency.location
+          cookbook = dependency.cached_cookbook
+          Berkshelf.log.debug "  Adding explicit dependency on #{cookbook}"
+          resolver.add_explicit_dependencies(cookbook)
         end
+      end
 
-        Berkshelf.log.debug "  Starting resolution..."
+      Berkshelf.log.debug "  Starting resolution..."
 
-        cookbooks = resolver.resolve.sort.map { |dependency| worker.future.install(dependency) }.map(&:value)
+      futures = resolver.resolve.sort.map { |dependency| Concurrent::Future.execute(executor: pool) { worker.install(dependency) } }
+      cookbooks = futures.map(&:value)
+      rejects = futures.select(&:rejected?)
+      raise rejects.first.reason unless rejects.empty?
 
-        [dependencies, cookbooks]
-      end
+      [dependencies, cookbooks]
+    end
 
-      def download_locations(dependencies)
-        dependencies.select(&:location).each do |dependency|
-          unless dependency.location.installed?
-            Berkshelf.formatter.fetch(dependency)
-            dependency.location.install
-          end
+    def download_locations(dependencies)
+      dependencies.select(&:location).each do |dependency|
+        unless dependency.location.installed?
+          Berkshelf.formatter.fetch(dependency)
+          dependency.location.install
         end
       end
+    end
   end
 end

data/lib/berkshelf/location.rb

@@ -9,7 +9,7 @@ module Berkshelf
       # is returned.
       #
       # @example Create a git location
-      #   Location.init(dependency, git: 'git://github.com/berkshelf/berkshelf.git')
+      #   Location.init(dependency, git: 'https://github.com/berkshelf/berkshelf.git')
       #
       # @example Create a GitHub location
       #   Location.init(dependency, github: 'berkshelf/berkshelf')
@@ -19,7 +19,7 @@ module Berkshelf
       #
       # @return [~BaseLocation, nil]
       def init(dependency, options = {})
-        if klass = klass_from_options(options)
+        if ( klass = klass_from_options(options) )
           klass.new(dependency, options)
         else
           nil
@@ -28,20 +28,20 @@ module Berkshelf
 
       private
 
-        # Load the correct location from the given options.
-        #
-        # @return [Class, nil]
-        def klass_from_options(options)
-          options.each do |key, _|
-            id = key.to_s.capitalize
-
-            begin
-              return Berkshelf.const_get("#{id}Location")
-            rescue NameError; end
-          end
+      # Load the correct location from the given options.
+      #
+      # @return [Class, nil]
+      def klass_from_options(options)
+        options.each do |key, _|
+          id = key.to_s.capitalize
 
-          nil
+          begin
+            return Berkshelf.const_get("#{id}Location")
+          rescue NameError; end
         end
+
+        nil
+      end
     end
   end
 end

data/lib/berkshelf/locations/base.rb

@@ -61,7 +61,7 @@ module Berkshelf
 
       begin
         cookbook = CachedCookbook.from_path(path)
-      rescue Ridley::Errors::RidleyError => e
+      rescue => e
         raise InternalError, "The following error occurred while reading the " \
           "cookbook `#{dependency.name}':\n#{e.class}: #{e.message}"
       end

data/lib/berkshelf/locations/git.rb

@@ -1,5 +1,3 @@
-require 'buff/shell_out'
-
 module Berkshelf
   class GitLocation < BaseLocation
     include Mixin::Git
@@ -22,7 +20,7 @@ module Berkshelf
       @rel      = options[:rel]
 
       # The revision to parse
-      @rev_parse = options[:ref] || options[:branch] || options[:tag] || 'master'
+      @rev_parse = options[:ref] || options[:branch] || options[:tag] || "master"
     end
 
     # @see BaseLoation#installed?
@@ -39,28 +37,22 @@ module Berkshelf
       scratch_path = Pathname.new(Dir.mktmpdir)
 
       if cached?
-        Dir.chdir(cache_path) do
-          git %|fetch --force --tags #{uri} "refs/heads/*:refs/heads/*"|
-        end
+        git(%{fetch --force --tags #{uri} "refs/heads/*:refs/heads/*"}, cwd: cache_path.to_s)
       else
-        git %|clone #{uri} "#{cache_path}" --bare --no-hardlinks|
+        git %{clone #{uri} "#{cache_path}" --bare --no-hardlinks}
       end
 
-      Dir.chdir(cache_path) do
-        @revision ||= git %|rev-parse #{@rev_parse}|
-      end
+      @revision ||= git(%{rev-parse #{@rev_parse}}, cwd: cache_path.to_s)
 
       # Clone into a scratch directory for validations
-      git %|clone --no-checkout "#{cache_path}" "#{scratch_path}"|
+      git %{clone --no-checkout "#{cache_path}" "#{scratch_path}"}
 
       # Make sure the scratch directory is up-to-date and account for rel paths
-      Dir.chdir(scratch_path) do
-        git %|fetch --force --tags "#{cache_path}"|
-        git %|reset --hard #{@revision}|
+      git(%{fetch --force --tags "#{cache_path}"}, cwd: scratch_path.to_s)
+      git(%{reset --hard #{@revision}}, cwd: scratch_path.to_s)
 
-        if rel
-          git %|filter-branch --subdirectory-filter "#{rel}" --force|
-        end
+      if rel
+        git(%{filter-branch --subdirectory-filter "#{rel}" --force}, cwd: scratch_path.to_s)
       end
 
       # Validate the scratched path is a valid cookbook
@@ -71,7 +63,7 @@ module Berkshelf
       FileUtils.mv(scratch_path, install_path)
 
       # Remove the git history
-      FileUtils.rm_rf(File.join(install_path, '.git'))
+      FileUtils.rm_rf(File.join(install_path, ".git"))
 
       install_path.chmod(0777 & ~File.umask)
     ensure
@@ -90,11 +82,11 @@ module Berkshelf
 
     def ==(other)
       other.is_a?(GitLocation) &&
-      other.uri == uri &&
-      other.branch == branch &&
-      other.tag == tag &&
-      other.shortref == shortref &&
-      other.rel == rel
+        other.uri == uri &&
+        other.branch == branch &&
+        other.tag == tag &&
+        other.shortref == shortref &&
+        other.rel == rel
     end
 
     def to_s
@@ -149,7 +141,7 @@ module Berkshelf
     # @return [Pathname]
     def cache_path
       Pathname.new(Berkshelf.berkshelf_path)
-        .join('.cache', 'git', Digest::SHA1.hexdigest(uri))
+        .join(".cache", "git", Digest::SHA1.hexdigest(uri))
     end
   end
 end

data/lib/berkshelf/locations/github.rb

@@ -1,6 +1,6 @@
 module Berkshelf
   class GithubLocation < GitLocation
-    HOST = 'github.com'
+    HOST = "github.com".freeze
     def initialize(dependency, options = {})
       protocol = Berkshelf::Config.instance.github_protocol || :https
       case protocol
@@ -9,7 +9,7 @@ module Berkshelf
       when :https
         options[:git] = "https://#{HOST}/#{options.delete(:github)}.git"
       when :git
-        options[:git] = "git://#{HOST}/#{options.delete(:github)}.git"
+        options[:git] = "https://#{HOST}/#{options.delete(:github)}.git"
       else
         # if some bizarre value is provided, treat it as :https
         options[:git] = "https://#{HOST}/#{options.delete(:github)}.git"

data/lib/berkshelf/locations/path.rb

@@ -49,8 +49,8 @@ module Berkshelf
 
     def ==(other)
       other.is_a?(PathLocation) &&
-      other.metadata? == metadata? &&
-      other.relative_path == relative_path
+        other.metadata? == metadata? &&
+        other.relative_path == relative_path
     end
 
     def to_lock