berkshelf 3.0.0.beta9 → 3.0.0.rc1

data/generator_files/CHANGELOG.md.erb

@@ -1,5 +1,9 @@
-# <%= name %> cookbook CHANGELOG
-This file is used to list changes made in each version of the <%= name %> cookbook.
+# 0.1.0
 
-## v0.1.0 (<%= Time.now.strftime('%Y-%m-%d') %>)
-- Initial release of <%= name %>
+Initial release of <%= name %>
+
+* Enhancements
+  * an enhancement
+
+* Bug Fixes
+  * a bug fix

data/generator_files/gitignore.erb

@@ -1,12 +1,17 @@
-.vagrant
-Berksfile.lock
 *~
 *#
 .#*
 \#*#
 .*.sw[a-z]
 *.un~
+pkg/
+
+# Berkshelf
+.vagrant
 /cookbooks
+<% unless options[:pattern] == "environment" -%>
+Berksfile.lock
+<% end -%>
 
 # Bundler
 Gemfile.lock

data/generator_files/metadata.rb.erb

@@ -3,9 +3,9 @@ maintainer       '<%= maintainer %>'
 maintainer_email '<%= maintainer_email %>'
 license          '<%= license_name %>'
 description      'Installs/Configures <%= name %>'
-long_description IO.read(File.join(File.dirname(__FILE__), 'README.md'))
+long_description 'Installs/Configures <%= name %>'
 <% if options[:scmversion] -%>
-version          IO.read(File.join(File.dirname(__FILE__), 'VERSION')) rescue '0.1.0'
+version          IO.read(File.join(File.dirname(__FILE__), 'VERSION'))
 <% else -%>
 version          '0.1.0'
 <% end -%>

data/lib/berkshelf.rb

@@ -24,6 +24,8 @@ module Berkshelf
     autoload :Logging, 'berkshelf/mixin/logging'
   end
 
+  autoload :Uploader, 'berkshelf/uploader'
+
   autoload :BaseFormatter,  'berkshelf/formatters/base'
   autoload :HumanFormatter, 'berkshelf/formatters/human'
   autoload :JsonFormatter,  'berkshelf/formatters/json'

data/lib/berkshelf/base_generator.rb

@@ -8,12 +8,30 @@ module Berkshelf
       end
     end
 
+    # A list of cookbook patterns accepted by generators inheriting from
+    # this generator.
+    #
+    # @return [Array<String>]
+    PATTERNS = [
+      "environment",
+      "application",
+      "library",
+      "wrapper"
+    ].freeze
+
     shell = Berkshelf.ui
 
     argument :path,
       type: :string,
       required: true
 
+    class_option :pattern,
+      type: :string,
+      default: "application",
+      desc: "Modifies the generated skeleton based on the given pattern.",
+      aliases: "-p",
+      enum: BaseGenerator::PATTERNS
+
     include Thor::Actions
 
     private

data/lib/berkshelf/berksfile.rb

@@ -378,18 +378,22 @@ module Berkshelf
     # @option options [String, Array<String>] :cookbooks
     #   Names of the cookbooks to retrieve dependencies for
     def update(*names)
+      validate_lockfile_present!
       validate_cookbook_names!(names)
 
+      Berkshelf.log.info "Updating cookbooks"
+
       # Calculate the list of cookbooks to unlock
       if names.empty?
-        list = dependencies
+        Berkshelf.log.debug "  Unlocking all the things!"
+        lockfile.unlock_all
       else
-        list = dependencies.select { |dependency| names.include?(dependency.name) }
+        names.each do |name|
+          Berkshelf.log.debug "  Unlocking #{name}"
+          lockfile.unlock(name, true)
+        end
       end
 
-      # Unlock any/all specified cookbooks
-      list.each { |dependency| lockfile.unlock(dependency) }
-
       # NOTE: We intentionally do NOT pass options to the installer
       self.install
     end
@@ -529,24 +533,11 @@ module Berkshelf
     # @return [Array<CachedCookbook>]
     #   the list of cookbooks that were uploaded to the Chef Server
     def upload(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      names   = args.flatten
-
       validate_lockfile_present!
       validate_lockfile_trusted!
       validate_dependencies_installed!
-      validate_cookbook_names!(names)
 
-      # Calculate the list of cookbooks from the given arguments
-      if names.empty?
-        list = dependencies
-      else
-        list = dependencies.select { |dependency| names.include?(dependency.name) }
-      end
-
-      cookbooks = cookbooks_for_upload(list)
-      ridley_upload(cookbooks, options)
-      cookbooks
+      Uploader.new(self, *args).run
     end
 
     # Package the given cookbook for distribution outside of berkshelf. If the
@@ -651,73 +642,6 @@ module Berkshelf
 
     private
 
-      def ridley_upload(cookbooks, options = {})
-        options = {
-          force:          false,
-          freeze:         true,
-          halt_on_frozen: false,
-          validate:       true,
-        }.merge(options)
-
-        skipped = []
-
-        Berkshelf.ridley_connection(options) do |conn|
-          cookbooks.each do |cookbook|
-            Berkshelf.formatter.upload(cookbook, conn)
-            validate_files!(cookbook)
-
-            begin
-              conn.cookbook.upload(cookbook.path, {
-                force: options[:force],
-                freeze: options[:freeze],
-                name: cookbook.cookbook_name,
-                validate: options[:validate]
-              })
-            rescue Ridley::Errors::FrozenCookbook => ex
-              if options[:halt_on_frozen]
-                raise FrozenCookbook.new(cookbook)
-              end
-
-              Berkshelf.formatter.skip(cookbook, conn)
-              skipped << cookbook
-            end
-          end
-        end
-
-        unless skipped.empty?
-          Berkshelf.formatter.msg "Skipped uploading some cookbooks because they" <<
-            " already exist on the remote server and are frozen. Re-run with the `--force`" <<
-            " flag to force overwrite these cookbooks:" <<
-            "\n\n" <<
-            "  * " << skipped.map { |c| "#{c.cookbook_name} (#{c.version})" }.join("\n  * ")
-        end
-      end
-
-      # Filter the given dependencies for upload. The dependencies of a cookbook
-      # will always be included in the filtered results, even if that
-      # dependency's name is not explicitly provided.
-      #
-      # @param [Array<Dependency>] dependencies
-      #   the list of dependencies to filter for upload
-      #
-      # @return [Array<CachedCookbook>]
-      #   the cookbook objects for uploading
-      def cookbooks_for_upload(dependencies)
-        dependencies.reduce({}) do |hash, dependency|
-          if hash[dependency.name].nil?
-            # TODO: make this a configurable option for advanced users to save
-            # time.
-            lockfile.graph.find(dependency).dependencies.each do |direct, _|
-              hash[direct] ||= lockfile.retrieve(direct)
-            end
-
-            hash[dependency.name] = lockfile.retrieve(dependency)
-          end
-
-          hash
-        end.values
-      end
-
       # Ensure the lockfile is present on disk.
       #
       # @raise [LockfileNotFound]
@@ -769,27 +693,11 @@ module Berkshelf
       # @raise [DependencyNotFound]
       #   if a cookbook name is given that does not exist
       def validate_cookbook_names!(names)
-        missing = names - dependencies.map(&:name)
+        missing = names - lockfile.graph.locks.keys
 
         unless missing.empty?
           raise DependencyNotFound.new(missing)
         end
       end
-
-      # Validate that the given cookbook does not have "bad" files. Currently
-      # this means including spaces in filenames (such as recipes)
-      #
-      # @param [CachedCookbook] cookbook
-      #  the Cookbook to validate
-      def validate_files!(cookbook)
-        path = cookbook.path.to_s
-
-        files = Dir.glob(File.join(path, '**', '*.rb')).select do |f|
-          parent = Pathname.new(path).dirname.to_s
-          f.gsub(parent, '') =~ /[[:space:]]/
-        end
-
-        raise InvalidCookbookFiles.new(cookbook, files) unless files.empty?
-      end
   end
 end

data/lib/berkshelf/cli.rb

@@ -197,7 +197,7 @@ module Berkshelf
     method_option :halt_on_frozen,
       type: :boolean,
       default: false,
-      desc: 'Halt uploading and exit if the Chef Server has a frozen version of the cookbook(s).'
+      desc: 'Exit with a non zero exit code if the Chef Server already has the version of the cookbook(s).'
     desc 'upload [COOKBOOKS]', 'Upload the cookbook specified in the Berksfile to the Chef Server'
     def upload(*names)
       berksfile = Berksfile.from_options(options)
@@ -279,6 +279,7 @@ module Berkshelf
 
       Berkshelf.formatter.msg 'Successfully initialized'
     end
+    tasks['init'].options = Berkshelf::InitGenerator.class_options
 
     method_option :berksfile,
       type: :string,
@@ -385,12 +386,13 @@ module Berkshelf
       Berkshelf.formatter.version
     end
 
-    desc 'cookbook NAME', 'Create a skeleton for a new cookbook'
-    def cookbook(name)
+    desc 'cookbook NAME [PATH]', 'Create a skeleton for a new cookbook'
+    def cookbook(name, path = nil)
+      path = File.join(Dir.pwd, name) if path.nil?
       Berkshelf.formatter.deprecation '--git is now the default' if options[:git]
       Berkshelf.formatter.deprecation '--vagrant is now the default' if options[:vagrant]
 
-      Berkshelf::CookbookGenerator.new([File.join(Dir.pwd, name), name], options).invoke_all
+      Berkshelf::CookbookGenerator.new([path, name], options).invoke_all
     end
     tasks['cookbook'].options = Berkshelf::CookbookGenerator.class_options
 

data/lib/berkshelf/cookbook_generator.rb

@@ -48,15 +48,26 @@ module Berkshelf
       default: Berkshelf.config.cookbook.email
 
     def generate
-      empty_directory target.join('files/default')
-      empty_directory target.join('templates/default')
-      empty_directory target.join('attributes')
-      empty_directory target.join('libraries')
-      empty_directory target.join('providers')
-      empty_directory target.join('recipes')
-      empty_directory target.join('resources')
-
-      template 'default_recipe.erb', target.join('recipes/default.rb')
+      case options[:pattern]
+      when "library"
+        empty_directory target.join("libraries")
+        empty_directory target.join("providers")
+        empty_directory target.join("resources")
+      when "wrapper"
+        empty_directory target.join("attributes")
+        empty_directory target.join("recipes")
+        template "default_recipe.erb", target.join("recipes/default.rb")
+      when "environment", "application"
+        empty_directory target.join("files/default")
+        empty_directory target.join("templates/default")
+        empty_directory target.join("attributes")
+        empty_directory target.join("libraries")
+        empty_directory target.join("providers")
+        empty_directory target.join("recipes")
+        empty_directory target.join("resources")
+        template "default_recipe.erb", target.join("recipes/default.rb")
+      end
+
       template 'metadata.rb.erb', target.join('metadata.rb')
       template license_file, target.join('LICENSE')
       template 'README.md.erb', target.join('README.md')

data/lib/berkshelf/formatters/base.rb

@@ -30,8 +30,8 @@ module Berkshelf
     formatter_method :package
     formatter_method :search
     formatter_method :show
-    formatter_method :skip
-    formatter_method :upload
+    formatter_method :skipping
+    formatter_method :uploaded
     formatter_method :use
     formatter_method :vendor
     formatter_method :version

data/lib/berkshelf/formatters/human.rb

@@ -40,15 +40,15 @@ module Berkshelf
     #
     # @param [Berkshelf::CachedCookbook] cookbook
     # @param [Ridley::Connection] conn
-    def upload(cookbook, conn)
-      Berkshelf.ui.info "Uploading #{cookbook.cookbook_name} (#{cookbook.version}) to: '#{conn.server_url}'"
+    def uploaded(cookbook, conn)
+      Berkshelf.ui.info "Uploaded #{cookbook.cookbook_name} (#{cookbook.version}) to: '#{conn.server_url}'"
     end
 
     # Output a Cookbook skip message using {Berkshelf.ui}
     #
     # @param [Berkshelf::CachedCookbook] cookbook
     # @param [Ridley::Connection] conn
-    def skip(cookbook, conn)
+    def skipping(cookbook, conn)
       Berkshelf.ui.info "Skipping #{cookbook.cookbook_name} (#{cookbook.version}) (frozen)"
     end
 

data/lib/berkshelf/formatters/json.rb

@@ -66,7 +66,7 @@ module Berkshelf
     #
     # @param [Berkshelf::CachedCookbook] cookbook
     # @param [Ridley::Connection] conn
-    def upload(cookbook, conn)
+    def uploaded(cookbook, conn)
       name = cookbook.cookbook_name
       cookbooks[name] ||= {}
       cookbooks[name][:version] = cookbook.version
@@ -77,7 +77,7 @@ module Berkshelf
     #
     # @param [Berkshelf::CachedCookbook] cookbook
     # @param [Ridley::Connection] conn
-    def skip(cookbook, conn)
+    def skipping(cookbook, conn)
       name = cookbook.cookbook_name
       cookbooks[name] ||= {}
       cookbooks[name][:version] = cookbook.version

data/lib/berkshelf/init_generator.rb

@@ -96,13 +96,7 @@ module Berkshelf
 
       if defined?(Kitchen::Generator::Init)
         unless options[:skip_test_kitchen]
-          # Temporarily use Dir.chdir to ensure the destination_root of test kitchen's generator
-          # is where we expect until this bug can be addressed:
-          # https://github.com/opscode/test-kitchen/pull/140
-          Dir.chdir target do
-            # Kitchen::Generator::Init.new([], {}, destination_root: target).invoke_all
-            Kitchen::Generator::Init.new([], {}).invoke_all
-          end
+          Kitchen::Generator::Init.new([], {}, destination_root: target).invoke_all
         end
       end
 

data/lib/berkshelf/installer.rb

@@ -146,7 +146,8 @@ module Berkshelf
         # Add any explicit dependencies for already-downloaded cookbooks (like
         # path locations)
         dependencies.each do |dependency|
-          if cookbook = dependency.cached_cookbook
+          if dependency.location
+            cookbook = dependency.cached_cookbook
             Berkshelf.log.debug "  Adding explicit dependency on #{cookbook}"
             resolver.add_explicit_dependencies(cookbook)
           end

data/lib/berkshelf/lockfile.rb

@@ -98,8 +98,6 @@ module Berkshelf
       berksfile.dependencies.each do |dependency|
         Berkshelf.log.debug "Checking #{dependency}"
 
-        checked[dependency.name] = true
-
         locked = find(dependency)
         if locked.nil?
           Berkshelf.log.debug "  Not in lockfile - cannot be trusted!"
@@ -152,17 +150,36 @@ module Berkshelf
     #   the list of already checked dependencies
     #
     # @return [Boolean]
-    def satisfies_transitive?(graph_item, checked)
-      graph_item.dependencies.all? do |name, constraint|
-        return true if checked[name]
+    def satisfies_transitive?(graph_item, checked, level = 0)
+      indent = ' '*(level + 2)
 
-        checked[name] = true
+      Berkshelf.log.debug "#{indent}Checking transitive dependencies for #{graph_item}"
+
+      if checked[graph_item.name]
+        Berkshelf.log.debug "#{indent}  Already checked - skipping"
+        return true
+      end
+
+      graph_item.dependencies.each do |name, constraint|
+        Berkshelf.log.debug "#{indent}  Checking #{name} (#{constraint})"
 
         graphed = graph.find(name)
-        return false if graphed.nil?
+        if graphed.nil?
+          Berkshelf.log.debug "#{indent}  Not graphed - cannot be satisifed"
+          return false
+        end
+
+        unless Semverse::Constraint.new(constraint).satisfies?(graphed.version)
+          Berkshelf.log.debug "#{indent}  Version constraint is not satisfied"
+          return false
+        end
 
-        Semverse::Constraint.new(constraint).satisfies?(graphed.version) &&
-        satisfies_transitive?(graphed, checked)
+        unless satisfies_transitive?(graphed, checked, level + 2)
+          Berkshelf.log.debug "#{indent}  Transitive are not satisifed"
+          return false
+        end
+
+        checked[name] = true
       end
     end
 
@@ -288,14 +305,22 @@ module Berkshelf
     # dependencies. Then it uses a recursive algorithm to safely remove any
     # other dependencies from the graph that are no longer needed.
     #
-    # @raise [CookbookNotFound]
-    #   if the provided dependency does not exist
-    #
     # @param [String] dependency
     #   the name of the cookbook to remove
-    def unlock(dependency)
+    def unlock(dependency, force = false)
       @dependencies.delete(Dependency.name(dependency))
-      graph.remove(dependency)
+
+      if force
+        graph.remove(dependency, ignore: graph.locks.keys)
+      else
+        graph.remove(dependency)
+      end
+    end
+
+    # Completely remove all dependencies from the lockfile and underlying graph.
+    def unlock_all
+      @dependencies = {}
+      @graph        = Graph.new(self)
     end
 
     # Iterate over each top-level dependency defined in the lockfile and
@@ -317,58 +342,72 @@ module Berkshelf
     #
     # @return [Array<Dependency>]
     def reduce!
-      # Store a list of cookbooks to ungraph
-      to_ungraph = {}
-      to_ignore  = {}
+      Berkshelf.log.info "Reducing lockfile"
+
+      Berkshelf.log.debug "Current lockfile:"
+      Berkshelf.log.debug ""
+      to_lock.each_line do |line|
+        Berkshelf.log.debug "  #{line.chomp}"
+      end
+      Berkshelf.log.debug ""
+
 
       # Unlock any locked dependencies that are no longer in the Berksfile
+      Berkshelf.log.debug "Unlocking dependencies no longer in the Berksfile"
+
       dependencies.each do |dependency|
-        unless berksfile.has_dependency?(dependency.name)
-          unlock(dependency)
-
-          # Keep a record. We know longer trust these dependencies, but simply
-          # unlocking them does not guarantee their removal from the graph.
-          # Instead, we keep a record of the dependency to unlock it later (in
-          # case it is actually removable because it's parent requirer is also
-          # being removed in this reduction). It's a form of science. Don't
-          # question it too much.
-          to_ungraph[dependency.name] = true
-          to_ignore[dependency.name]  = true
+        Berkshelf.log.debug "  Checking #{dependency}"
+
+        if berksfile.has_dependency?(dependency.name)
+          Berkshelf.log.debug "    Skipping unlock for #{dependency.name} (exists in the Berksfile)"
+        else
+          Berkshelf.log.debug "    Unlocking #{dependency.name}"
+          unlock(dependency, true)
         end
       end
 
       # Remove any transitive dependencies
+      Berkshelf.log.debug "Removing transitive dependencies"
+
       berksfile.dependencies.each do |dependency|
+        Berkshelf.log.debug "  Checking #{dependency}"
+
         graphed = graph.find(dependency)
-        next if graphed.nil?
+
+        if graphed.nil?
+          Berkshelf.log.debug "    Skipping (not graphed)"
+          next
+        end
 
         unless dependency.version_constraint.satisfies?(graphed.version)
+          Berkshelf.log.debug "    Constraints are not satisfied!"
           raise OutdatedDependency.new(graphed, dependency)
         end
 
         if cookbook = dependency.cached_cookbook
+          Berkshelf.log.debug "    Cached cookbook exists"
+          Berkshelf.log.debug "    Checking dependencies on the cached cookbook"
+
           graphed.dependencies.each do |name, constraint|
+            Berkshelf.log.debug "      Checking #{name} (#{constraint})"
+
             # Unless the cookbook still depends on this key, we want to queue it
             # for unlocking. This is the magic that prevents transitive
             # dependency leaking.
             unless cookbook.dependencies.has_key?(name)
-              to_ungraph[name] = true
-
-              # We also want to ignore the top-level dependency. We can no
-              # longer trust the graph that we have been given for that
-              # dependency and therefore need to reduce it.
-              to_ignore[dependency.name] = true
+              Berkshelf.log.debug "        Not found!"
+              unlock(name, true)
             end
           end
         end
       end
 
-      # Now remove all the unlockable items
-      ignore = to_ungraph.merge(to_ignore).keys
-
-      to_ungraph.each do |name, _|
-        graph.remove(name, ignore: ignore)
+      Berkshelf.log.debug "New lockfile:"
+      Berkshelf.log.debug ""
+      to_lock.each_line do |line|
+        Berkshelf.log.debug "  #{line.chomp}"
       end
+      Berkshelf.log.debug ""
     end
 
 
@@ -566,6 +605,10 @@ module Berkshelf
             dependency = @lockfile.find(name)  ||
                          @berksfile && @berksfile.find(name) ||
                          Dependency.new(@berksfile, name)
+
+            # We need to make a copy of the dependency, or else we could be
+            # modifying an existing object that other processes depend on!
+            dependency = dependency.dup
             dependency.locked_version = item.version
 
             hash[item.name] = dependency
@@ -748,6 +791,11 @@ module Berkshelf
             def add_dependency(name, constraint)
               @dependencies[name.to_s] = constraint.to_s
             end
+
+            # @private
+            def to_s
+              "#{name} (#{version})"
+            end
           end
       end
   end