berkshelf 0.1.1

data/features/step_definitions/filesystem_steps.rb

@@ -0,0 +1,79 @@
+require 'aruba/api'
+
+World(Aruba::Api)
+
+Given /^a cookbook named "(.*?)"$/ do |name|
+  steps %{
+    Given a directory named "#{name}"
+    And an empty file named "#{name}/metadata.rb"
+  }
+end
+
+Given /^I do not have a Berksfile$/ do
+  in_current_dir { FileUtils.rm_f(Berkshelf::DEFAULT_FILENAME) }
+end
+
+Given /^I do not have a Berksfile\.lock$/ do
+  in_current_dir { FileUtils.rm_f(Berkshelf::Lockfile::DEFAULT_FILENAME) }
+end
+
+Given /^the cookbook "(.*?)" has the file "(.*?)" with:$/ do |cookbook_name, file_name, content|
+  write_file(File.join(cookbook_name, file_name), content)
+end
+
+Then /^the cookbook store should have the cookbooks:$/ do |cookbooks|
+  cookbooks.raw.each do |name, version|
+    cookbook_store.should have_structure {
+      directory "#{name}-#{version}" do
+        file "metadata.rb" do
+          contains version
+        end
+      end
+    }
+  end
+end
+
+Then /^the cookbook store should not have the cookbooks:$/ do |cookbooks|
+  cookbooks.raw.each do |name, version|
+    cookbook_store.should_not have_structure {
+      directory "#{name}-#{version}"
+    }
+  end
+end
+
+Then /^the cookbook "(.*?)" should have the following files:$/ do |name, files|
+  check_file_presence(files.raw.map{|file_row| File.join(name, file_row[0])}, true)
+end
+
+Then /^the file "(.*?)" in the cookbook "(.*?)" should contain:$/ do |file_name, cookbook_name, content|
+  Pathname.new(current_dir).join(cookbook_name).should have_structure {
+    file "Berksfile" do
+      contains content
+    end
+    file ".chefignore"
+  }
+end
+
+Then /^the directory "(.*?)" should have the following files:$/ do |name, files|
+  check_file_presence(files.raw.map{|file_row| File.join(name, file_row[0])}, true)
+end
+
+Then /^the directory "(.*?)" should not have the following files:$/ do |name, files|
+  check_file_presence(files.raw.map{|file_row| File.join(name, file_row[0])}, false)
+end
+
+Then /^the file "(.*?)" in the directory "(.*?)" should not contain:$/ do |file_name, directory_name, content|
+  Pathname.new(current_dir).join(directory_name).should_not have_structure {
+    file "Berksfile" do
+      contains content
+    end
+  }
+end
+
+Then /^the current directory should have the following files:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, true)
+end
+
+Then /^the current directory should not have the following files:$/ do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
+end

data/features/support/env.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'spork'
+
+Spork.prefork do
+  require 'rspec'
+  require 'pp'
+  require 'aruba/cucumber'
+  require 'vcr'
+
+  APP_ROOT = File.expand_path('../../../', __FILE__)
+
+  ENV["BERKSHELF_PATH"] = File.join(APP_ROOT, "tmp", "berkshelf")
+  
+  Dir[File.join(APP_ROOT, "spec/support/**/*.rb")].each {|f| require f}
+
+  Around do |scenario, block|
+    VCR.use_cassette(scenario.title) do
+      block.call
+    end
+  end
+
+  Before do
+    Chef::Config[:chef_server_url] = config['chef_server_url']
+    Chef::Config[:client_key] = config['client_key']
+    Chef::Config[:node_name] = config['node_name']
+    clean_cookbook_store
+    @aruba_io_wait_seconds = 5
+  end
+
+  Before('@slow_process') do
+    @aruba_timeout_seconds = 15
+    @aruba_io_wait_seconds = 10
+  end
+
+  def cookbook_store
+    Pathname.new(ENV["BERKSHELF_PATH"])
+  end
+
+  def clean_cookbook_store
+    FileUtils.rm_rf(cookbook_store)
+    FileUtils.mkdir_p(cookbook_store)
+  end
+
+  def config
+    @config ||= YAML.load(File.read(File.join(APP_ROOT, "features", "config.yml")))
+  rescue Errno::ENOENT
+    raise "Please create a config file at features/config.yml from the sample found at features/config.sample.yml"
+  end
+end
+
+Spork.each_run do
+  require 'berkshelf'
+end

data/features/update.feature

@@ -0,0 +1,23 @@
+Feature: update
+  As a user
+  I want a way to update the versions without clearing out the files I've downloaded
+  So that I can update faster than a clean install
+
+  Scenario: knife berkshelf update
+    Given I write to "Berksfile" with:
+      """
+      cookbook "mysql"
+      """
+    Given I write to "Berksfile.lock" with:
+      """
+      cookbook 'mysql', :locked_version => '0.0.1'
+      cookbook 'openssl', :locked_version => '0.0.1'
+      """
+    When I run the update command
+    Then the file "Berksfile.lock" should contain exactly:
+      """
+      cookbook 'mysql', :locked_version => '1.2.6'
+      cookbook 'openssl', :locked_version => '1.0.0'
+      cookbook 'chef_handler', :locked_version => '1.0.6'
+      cookbook 'windows', :locked_version => '1.3.0'
+      """

data/features/upload_command.feature

@@ -0,0 +1,43 @@
+Feature: upload command
+  As a Berkshelf CLI user
+  I need a way to upload cookbooks to a Chef server that I have installed into my Bookshelf
+  So they are available to Chef clients
+
+  @wip @slow_process
+  Scenario: running the upload command when the Sources in the Berksfile are already installed
+    Given I write to "Berksfile" with:
+      """
+      cookbook "mysql", "1.2.4"
+      """
+    And the Chef server does not have the cookbooks:
+      | mysql   | 1.2.4 |
+      | openssl | 1.0.0 |
+    And I run the install command
+    When I run the upload command
+    Then the output should not contain "Using mysql (1.2.4)"
+    And the output should not contain "Using openssl (1.0.0)"
+    And the output should contain "Uploading mysql (1.2.4) to:"
+    And the output should contain "Uploading openssl (1.0.0) to:"
+    And the Chef server should have the cookbooks:
+      | mysql   | 1.2.4 |
+      | openssl | 1.0.0 |
+    And the exit status should be 0
+
+  @slow_process
+  Scenario: running the upload command when the Sources in the Berksfile have not been installed
+    Given I write to "Berksfile" with:
+      """
+      cookbook "mysql", "1.2.4"
+      """
+    And the Chef server does not have the cookbooks:
+      | mysql   | 1.2.4 |
+      | openssl | 1.0.0 |
+    When I run the upload command
+    Then the output should contain "Installing mysql (1.2.4) from site:"
+    And the output should contain "Installing openssl (1.0.0) from site:"
+    And the output should contain "Uploading mysql (1.2.4) to:"
+    And the output should contain "Uploading openssl (1.0.0) to:"
+    And the Chef server should have the cookbooks:
+      | mysql   | 1.2.4 |
+      | openssl | 1.0.0 |
+    And the exit status should be 0

data/features/without.feature

@@ -0,0 +1,25 @@
+Feature: --without block
+  As a user
+  I want to be able to exclude blocks in my Berksfile
+  So I can have cookbooks organized for use in different situations in a single Berksfile
+
+  @slow_process
+  Scenario: Exclude a block
+    Given I write to "Berksfile" with:
+      """
+      group :notme do
+        cookbook "nginx", "= 0.101.2"
+      end
+      
+      cookbook "mysql", "= 1.2.4"
+
+      group :takeme do
+        cookbook "ntp", "= 1.1.8"
+      end
+      """
+    When I run `knife berks install --without notme`
+    Then the cookbook store should have the cookbooks:
+      | mysql | 1.2.4 |
+      | ntp   | 1.1.8 |
+    And the cookbook store should not have the cookbooks:
+      | nginx | 0.101.2 |

data/lib/berkshelf.rb

@@ -0,0 +1,90 @@
+require 'pathname'
+require 'dep_selector'
+require 'zlib'
+require 'archive/tar/minitar'
+require 'chef/knife'
+require 'chef/rest'
+require 'chef/platform'
+require 'chef/cookbook/metadata'
+
+require 'berkshelf/version'
+require 'berkshelf/core_ext'
+require 'berkshelf/errors'
+
+Chef::Config[:cache_options][:path] = Dir.mktmpdir
+
+module Berkshelf
+  DEFAULT_STORE_PATH = File.expand_path("~/.berkshelf").freeze
+  DEFAULT_FILENAME = 'Berksfile'.freeze
+
+  autoload :DSL, 'berkshelf/dsl'
+  autoload :Git, 'berkshelf/git'
+  autoload :Berksfile, 'berkshelf/berksfile'
+  autoload :Lockfile, 'berkshelf/lockfile'
+  autoload :InitGenerator, 'berkshelf/init_generator'
+  autoload :CookbookSource, 'berkshelf/cookbook_source'
+  autoload :CookbookStore, 'berkshelf/cookbook_store'
+  autoload :CachedCookbook, 'berkshelf/cached_cookbook'
+  autoload :TXResult, 'berkshelf/tx_result'
+  autoload :TXResultSet, 'berkshelf/tx_result_set'
+  autoload :Downloader, 'berkshelf/downloader'
+  autoload :Uploader, 'berkshelf/uploader'
+  autoload :Resolver, 'berkshelf/resolver'
+
+  class << self
+    attr_accessor :ui
+    attr_accessor :cookbook_store
+    attr_accessor :downloader
+
+    def root
+      File.join(File.dirname(__FILE__), '..')
+    end
+
+    def ui
+      @ui ||= Chef::Knife::UI.new(null_stream, null_stream, STDIN, {})
+    end
+
+    # Returns the filepath to the location Cookbooks will be downloaded to
+    # or uploaded from. By default this is '~/.berkshelf' but can be overridden
+    # by specifying a value for the ENV variable 'BERKSHELF_PATH'.
+    # 
+    # @return [String]
+    def berkshelf_path
+      ENV["BERKSHELF_PATH"] || DEFAULT_STORE_PATH
+    end
+
+    def cookbook_store
+      @cookbook_store ||= CookbookStore.new(berkshelf_path)
+    end
+
+    def downloader
+      @downloader ||= Downloader.new(cookbook_store)
+    end
+
+    # Ascend the directory structure from the given path to find a
+    # metadata.rb file of a Chef Cookbook. If no metadata.rb file
+    # was found, nil is returned.
+    #
+    # @return [Pathname] 
+    #   path to metadata.rb 
+    def find_metadata(path = Dir.pwd)
+      path = Pathname.new(path)
+      path.ascend do |potential_root|
+        if potential_root.entries.collect(&:to_s).include?('metadata.rb')
+          return potential_root.join('metadata.rb')
+        end
+      end
+    end
+
+    private
+
+      def null_stream
+        @null ||= begin
+          strm = STDOUT.clone
+          strm.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+          strm.sync = true
+          strm
+        end
+      end
+  end
+end

data/lib/berkshelf/berksfile.rb

@@ -0,0 +1,170 @@
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Berksfile
+    include DSL
+
+    class << self
+      def from_file(file)
+        content = File.read(file)
+        read(content)
+      rescue Errno::ENOENT => e
+        raise BerksfileNotFound, "No Berksfile or Berksfile.lock found at: #{file}"
+      end
+
+      def read(content)
+        object = new
+        object.instance_eval(content)
+
+        object
+      end
+
+      # @param [Array] sources
+      #   an array of sources to filter
+      # @param [Array, Symbol] excluded
+      #   an array of symbols or a symbol representing the group or group(s)
+      #   to exclude
+      #
+      # @return [Array<Berkshelf::CookbookSource>]
+      #   an array of sources that are not members of the excluded group(s)
+      def filter_sources(sources, excluded)
+        excluded = Array(excluded)
+        excluded.collect!(&:to_sym)
+
+        sources.select { |source| (excluded & source.groups).empty? }
+      end
+    end
+
+    def initialize
+      @sources = Hash.new
+    end
+
+    # Add the given source to the sources array. A DuplicateSourceDefined
+    # exception will be raised if a source is added whose name conflicts
+    # with a source who has already been added.
+    #
+    # @param [Berkshelf::CookbookSource] source
+    #   the source to add
+    #
+    # @return [Array<Berkshelf::CookbookSource]
+    def add_source(source)
+      raise DuplicateSourceDefined if has_source?(source)
+      @sources[source.to_s] = source
+    end
+
+    # @param [#to_s] source
+    #   the source to remove
+    #
+    # @return [Berkshelf::CookbookSource]
+    def remove_source(source)
+      @sources.delete(source.to_s)
+    end
+
+    # @param [#to_s] source
+    #   the source to check presence of
+    #
+    # @return [Boolean]
+    def has_source?(source)
+      @sources.has_key?(source.to_s)
+    end
+
+    # @param [Hash] options
+    #   a hash of options
+    #
+    #   Options:
+    #     exclude: An array of groups to exclude from the returned Array
+    #       of sources
+    #
+    # @return [Array<Berkshelf::CookbookSource>]
+    def sources(options = {})
+      l_sources = @sources.collect { |name, source| source }.flatten
+
+      if options[:exclude]
+        self.class.filter_sources(l_sources, options[:exclude])
+      else
+        l_sources
+      end
+    end
+
+    # @return [Hash]
+    #   a hash containing group names as keys and an array of CookbookSources
+    #   that are a member of that group as values
+    #
+    #   Example:
+    #     {
+    #       nautilus: [
+    #         #<Berkshelf::CookbookSource @name="nginx">,
+    #         #<Berkshelf::CookbookSource @name="mysql">,
+    #       ],
+    #       skarner: [
+    #         #<Berkshelf::CookbookSource @name="nginx">
+    #       ]
+    #     }
+    def groups
+      {}.tap do |groups|
+        @sources.each_pair do |name, source|
+          source.groups.each do |group|
+            groups[group] ||= []
+            groups[group] << source
+          end
+        end
+      end
+    end
+
+    # @param [String] name
+    #   name of the source to return
+    #
+    # @return [Berkshelf::CookbookSource]
+    def [](name)
+      @sources[name]
+    end
+    alias_method :get_source, :[]
+
+    # @param [Hash] options
+    #   a hash of options
+    #   
+    #   Options:
+    #     without: An array of groups to exclude which will cause any sources
+    #       marked as a member of the group to not be installed
+    def install(options = {})
+      resolver = Resolver.new(Berkshelf.downloader, sources(exclude: options[:without]))
+      resolver.resolve
+      write_lockfile(resolver.sources) unless lockfile_present?
+    end
+
+    # @param [String] chef_server_url
+    #   the full URL to the Chef Server to upload to
+    #
+    #   Example:
+    #     "https://api.opscode.com/organizations/vialstudios"
+    #
+    # @param [Hash] options
+    #   a hash of options
+    #
+    #   Options:
+    #     without: An array of groups to exclude which will cause any sources
+    #       marked as a member of the group to not be installed
+    #     force: Upload the Cookbook even if the version already exists and is
+    #       frozen on the target Chef Server
+    #     freeze: Freeze the uploaded Cookbook on the Chef Server so that it
+    #       cannot be overwritten
+    def upload(chef_server_url, options = {})
+      uploader = Uploader.new(Berkshelf.cookbook_store, chef_server_url)
+      resolver = Resolver.new(Berkshelf.downloader, sources(exclude: options[:without]))  
+
+      resolver.resolve.each do |name, version|
+        Berkshelf.ui.info "Uploading #{name} (#{version}) to: #{chef_server_url}"
+        uploader.upload!(name, version, options)
+      end
+    end
+
+    private
+
+      def lockfile_present?
+        File.exist?(Berkshelf::Lockfile::DEFAULT_FILENAME)
+      end
+
+      def write_lockfile(sources)
+        Berkshelf::Lockfile.new(sources).write
+      end
+  end
+end