knife_cookbook_dependencies_over_http 0.0.8

data/lib/kcd/dsl.rb

@@ -0,0 +1,13 @@
+module KnifeCookbookDependencies
+  module DSL
+    def cookbook(*args)
+      KCD.shelf.shelve_cookbook(*args)
+    end
+
+    def group *args
+      KCD.shelf.active_group = args
+      yield
+      KCD.shelf.active_group = nil
+    end
+  end
+end

data/lib/kcd/error_messages.rb

@@ -0,0 +1,13 @@
+module KnifeCookbookDependencies
+  module ErrorMessages
+    class << self
+      def missing_cookbook(name)
+        "The cookbook #{name} was not found on the Opscode Community site. Provide a git or path key for #{name} if it is unpublished."
+      end
+
+      def missing_cookbookfile
+        "There is no Cookbookfile in #{Dir.pwd}."
+      end
+    end
+  end
+end

data/lib/kcd/git.rb

@@ -0,0 +1,86 @@
+require 'tempfile'
+
+module KnifeCookbookDependencies
+  class Git
+    class << self
+      def git
+        @git ||= find_git
+      end
+
+      #
+      # This is to defeat aliases/shell functions called 'git' and a number of
+      # other problems.
+      #
+      def find_git
+        git_path = nil
+        ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+          potential_path = File.join(path, 'git')
+          if File.executable?(potential_path)
+            git_path = potential_path
+            break
+          end
+        end
+
+        unless git_path
+          raise "Could not find git. Please ensure it is in your path."
+        end
+
+        return git_path
+      end
+    end
+
+    attr_reader :directory
+    attr_reader :repository
+
+    def initialize(repo)
+      @repository = repo
+    end
+
+    def clone
+      # XXX not sure how resilient this is, maybe a fetch/merge strategy would be better.
+      if @directory
+        Dir.chdir @directory do
+          system(self.class.git, "pull")
+        end
+      else
+        @directory = Dir.mktmpdir
+        system(self.class.git, "clone", @repository, @directory)
+      end
+
+      error_check
+
+    end
+
+    def checkout(ref)
+      clone
+
+      Dir.chdir @directory do
+        system(self.class.git, "checkout", "-q", ref)
+      end
+
+      error_check
+    end
+
+    def ref
+      return nil unless @directory
+
+      this_ref = nil
+
+      Dir.chdir @directory do
+        this_ref = `#{self.class.git} rev-parse HEAD`.strip
+      end
+
+      return this_ref
+    end
+
+    def clean
+      FileUtils.rm_rf @directory if @directory
+    end
+
+    def error_check
+      if $?.exitstatus != 0
+        raise "Did not succeed executing git; check the output above."
+      end
+    end
+  end
+end

data/lib/kcd/knife_utils.rb

@@ -0,0 +1,13 @@
+require 'stringio'
+require 'chef/config'
+
+module KnifeCookbookDependencies
+  module KnifeUtils
+    def self.capture_knife_output(knife_obj)
+      knife_obj.ui = Chef::Knife::UI.new(StringIO.new, StringIO.new, StringIO.new, :format => :json)
+      knife_obj.run
+      knife_obj.ui.stdout.rewind
+      knife_obj.ui.stdout.read
+    end
+  end
+end

data/lib/kcd/lockfile.rb

@@ -0,0 +1,40 @@
+module KnifeCookbookDependencies
+  class Lockfile
+    DEFAULT_FILENAME = "#{KCD::DEFAULT_FILENAME}.lock"
+
+    def initialize(cookbooks)
+      @cookbooks = cookbooks
+    end
+
+    def write(filename = DEFAULT_FILENAME)
+      content = @cookbooks.map do |cookbook|
+                  get_cookbook_definition(cookbook)
+                end.join("\n")
+      File.open(DEFAULT_FILENAME, "wb") { |f| f.write content }
+    end
+
+    def get_cookbook_definition(cookbook)
+      definition = "cookbook '#{cookbook.name}'"
+
+      if cookbook.from_git?
+        definition += ", :git => '#{cookbook.git_repo}', :ref => '#{cookbook.git_ref || 'HEAD'}'"
+      elsif cookbook.from_path?
+        definition += ", :path => '#{cookbook.local_path}'"
+      else
+        definition += ", :locked_version => '#{cookbook.locked_version}'"
+      end
+
+      return definition
+    end
+
+    def remove!
+      self.class.remove!
+    end
+
+    class << self
+      def remove!
+        FileUtils.rm_f DEFAULT_FILENAME
+      end
+    end
+  end
+end

data/lib/kcd/metacookbook.rb

@@ -0,0 +1,18 @@
+module KnifeCookbookDependencies
+  class MetaCookbook
+    attr_reader :name, :dependencies
+
+    def initialize(name, dependencies)
+      @name = name
+      @dependencies = dependencies
+    end
+
+    def versions
+      @v ||= [DepSelector::Version.new('1.0.0')]
+    end
+
+    def latest_constrained_version
+      versions.first
+    end
+  end
+end

data/lib/kcd/shelf.rb

@@ -0,0 +1,100 @@
+module KnifeCookbookDependencies
+  class Shelf
+    META_COOKBOOK_NAME = 'cookbook_dependencies_shelf'
+
+    attr_accessor :cookbooks, :active_group, :excluded_groups
+
+    def initialize
+      @cookbooks = []
+    end
+    
+    def shelve_cookbook(*args)
+      @cookbooks << (args.first.is_a?(Cookbook) ? args.first : Cookbook.new(*args))
+    end
+
+    def resolve_dependencies
+      graph = DepSelector::DependencyGraph.new
+
+      post_exclusions = requested_cookbooks
+      cookbooks_to_install = @cookbooks.select {|c| post_exclusions.include?(c.name)}
+      # all cookbooks in the Cookbookfile are dependencies of the shelf
+      shelf = MetaCookbook.new(META_COOKBOOK_NAME, cookbooks_to_install)
+
+      self.class.populate_graph graph, shelf
+
+      
+      selector = DepSelector::Selector.new(graph)
+
+      solution = quietly do
+        selector.find_solution([DepSelector::SolutionConstraint.new(graph.package(META_COOKBOOK_NAME))])
+      end
+
+      solution.delete META_COOKBOOK_NAME
+      solution
+    end
+
+    def write_lockfile
+      KCD::Lockfile.new(@cookbooks).write
+    end
+
+    def get_cookbook(name)
+      @cookbooks.select { |c| c.name == name }.first
+    end
+
+    def populate_cookbooks_directory
+      cookbooks_from_path = @cookbooks.select(&:from_path?) | @cookbooks.select(&:from_git?)
+      KCD.ui.info "Fetching cookbooks:"
+      resolve_dependencies.each_pair do |cookbook_name, version|
+        cookbook = cookbooks_from_path.select { |c| c.name == cookbook_name }.first || Cookbook.new(cookbook_name, version.to_s)
+        @cookbooks << cookbook
+        cookbook.download
+        cookbook.unpack
+        cookbook.copy_to_cookbooks_directory
+        cookbook.locked_version = version
+      end
+      @cookbooks = @cookbooks.uniq.reject { |x| x.locked_version.nil? }
+    end
+
+    def exclude(groups)
+      groups = groups.to_s.split(/[,:]/) unless groups.is_a?(Array)
+      @excluded_groups = groups.collect {|c| c.to_sym}
+    end
+
+    def cookbook_groups
+      {}.tap do |groups|
+        @cookbooks.each do |cookbook|
+          cookbook.groups.each do |group|
+            groups[group] ||= []
+            groups[group] << cookbook.name
+          end
+        end
+      end
+    end
+
+    def requested_cookbooks
+      return @cookbooks.collect(&:name) unless @excluded_groups
+      [].tap do |r|
+        cookbook_groups.each do |group, cookbooks|
+          r << cookbooks unless @excluded_groups.include?(group.to_sym)
+        end
+      end.flatten.uniq
+    end
+
+    class << self
+      def populate_graph(graph, cookbook)
+        package = graph.package cookbook.name
+        cookbook.versions.each { |v| package.add_version(v) }
+        cookbook.dependencies.each do |dependency|
+          graph = populate_graph(graph, dependency)
+          dep = graph.package(dependency.name)
+          version = package.versions.select { |v| v.version == cookbook.latest_constrained_version }.first
+          dependency.version_constraints.each do |constraint|
+            version.dependencies << DepSelector::Dependency.new(dep, constraint)
+          end
+        end
+
+        graph
+      end
+    end
+  end
+end

data/lib/kcd/version.rb

@@ -0,0 +1,3 @@
+module KnifeCookbookDependencies
+  VERSION = "0.0.8"
+end

data/lib/knife_cookbook_dependencies.rb

@@ -0,0 +1,53 @@
+module KnifeCookbookDependencies
+  DEFAULT_FILENAME = 'Cookbookfile'
+  COOKBOOKS_DIRECTORY = 'cookbooks'
+  TMP_DIRECTORY = File.join(ENV['TMPDIR'], 'knife_cookbook_dependencies')
+  FileUtils.mkdir_p TMP_DIRECTORY
+
+  autoload :KnifeUtils, 'kcd/knife_utils'
+
+  class << self
+    attr_accessor :ui
+
+    def root
+      File.join(File.dirname(__FILE__), '..')
+    end
+
+    def shelf
+      @shelf ||= KCD::Shelf.new
+    end
+
+    def clear_shelf!
+      @shelf = nil
+    end
+
+    def ui
+      @ui ||= Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
+    end
+
+    def clean
+      clear_shelf!
+      Lockfile.remove!
+      FileUtils.rm_rf COOKBOOKS_DIRECTORY
+      FileUtils.rm_rf TMP_DIRECTORY
+    end
+  end
+end
+
+# Alias for {KnifeCookbookDependencies}
+KCD = KnifeCookbookDependencies
+
+require 'dep_selector'
+require 'zlib'
+require 'archive/tar/minitar'
+
+require 'kcd/version'
+require 'kcd/shelf'
+require 'kcd/cookbook'
+require 'kcd/metacookbook'
+require 'kcd/dsl'
+require 'kcd/cookbookfile'
+require 'kcd/lockfile'
+require 'kcd/git'
+require 'kcd/error_messages'
+require 'kcd/core_ext/kernel'

data/spec/fixtures/cookbooks/example_cookbook/README.md

@@ -0,0 +1,12 @@
+Description
+===========
+
+Requirements
+============
+
+Attributes
+==========
+
+Usage
+=====
+

data/spec/fixtures/cookbooks/example_cookbook/metadata.rb

@@ -0,0 +1,6 @@
+maintainer       "Josiah Kiehl"
+maintainer_email "josiah@skirmisher.net"
+license          "DO WHAT YOU WANT CAUSE A PIRATE IS FREE"
+description      "Installs/Configures example_cookbook"
+long_description IO.read(File.join(File.dirname(__FILE__), 'README.md'))
+version          "0.5.0"

data/spec/fixtures/cookbooks/example_cookbook/recipes/default.rb

@@ -0,0 +1,8 @@
+#
+# Cookbook Name:: example_cookbook
+# Recipe:: default
+#
+# Copyright 2012, YOUR_COMPANY_NAME
+#
+# All rights reserved - Do Not Redistribute
+#

data/spec/fixtures/lockfile_spec/with_lock/Cookbookfile

@@ -0,0 +1 @@
+cookbook 'nginx', '= 0.101.0'

data/spec/fixtures/lockfile_spec/without_lock/Cookbookfile.lock

@@ -0,0 +1,5 @@
+cookbook 'nginx', :locked_version => '0.101.0'
+cookbook 'build-essential', :locked_version => '1.0.0'
+cookbook 'runit', :locked_version => '0.15.0'
+cookbook 'bluepill', :locked_version => '1.0.4'
+cookbook 'ohai', :locked_version => '1.0.2'

data/spec/lib/kcd/cookbook_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+module KnifeCookbookDependencies
+  describe Cookbook do
+    subject { Cookbook.new('ntp') }
+
+    after do
+      subject.clean
+    end
+
+    describe do
+      before do
+        Cookbook.any_instance.stub(:versions).and_return ['0.1.1', '0.9.0', '1.0.0', '1.1.8'].collect {|v| Gem::Version.new(v) }
+      end
+
+      # FIXME: This test is flakey
+      it "should raise an error if the cookbook is unpacked without being downloaded first" do
+        -> { subject.unpack(subject.unpacked_cookbook_path, :clean => true, :download => false) }.should raise_error
+      end
+
+      describe '#unpacked_cookbook_path' do
+        it "should give the path to the directory where the archive should get unpacked" do
+          subject.unpacked_cookbook_path.should == File.join(KCD::TMP_DIRECTORY, 'ntp-1.1.8')
+        end
+      end
+
+      it 'should treat cookbooks pulled from a path like a cookbook that has already been unpacked with the path as the unpacked location' do
+        example_cookbook_from_path.unpacked_cookbook_path.should == File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "spec", "fixtures", "cookbooks"))
+      end
+
+      it "should not attempt to download a cookbook being pulled from a path" do
+        Chef::Knife::CookbookSiteDownload.any_instance.should_not_receive(:run)
+        example_cookbook_from_path.download
+      end
+
+      describe "#copy_to" do
+        it "should copy from the unpacked cookbook directory to the target" do
+          example_cookbook_from_path.copy_to_cookbooks_directory
+          File.exists?(File.join(KCD::COOKBOOKS_DIRECTORY, example_cookbook_from_path.name)).should be_true
+        end
+      end
+    end
+
+    describe "#versions" do
+      it "should return the version in the metadata file as the available versions for a path sourced cookbook" do
+        example_cookbook_from_path.versions.should == [DepSelector::Version.new('0.5.0')]
+      end
+    end
+
+    describe '#version_from_metadata' do
+      it "should return the correct version" do
+        subject.version_from_metadata.should == DepSelector::Version.new('1.1.8')
+      end
+    end
+
+    describe '#version_constraints_include?' do
+      it "should cycle through all the version constraints to confirm that all of them are satisfied" do
+        subject.add_version_constraint ">= 1.0.0"
+        subject.add_version_constraint "< 2.0.0"
+        subject.version_constraints_include?(DepSelector::Version.new('1.0.0')).should be_true
+        subject.version_constraints_include?(DepSelector::Version.new('1.5.0')).should be_true
+        subject.version_constraints_include?(DepSelector::Version.new('2.0.0')).should be_false
+      end
+    end
+
+    describe '#add_version_constraint' do
+      it "should not duplicate version constraints" do
+        subject.add_version_constraint ">= 1.0.0"
+        subject.add_version_constraint ">= 1.0.0"
+        subject.add_version_constraint ">= 1.0.0"
+        subject.add_version_constraint ">= 1.0.0"
+        subject.version_constraints.size.should == 2 # 1 for the
+                                                     # default when
+                                                     # the cookbook
+                                                     # was created in
+                                                     # the subject
+                                                     # instantiation
+                                                     # line
+      end
+    end
+
+    describe '#dependencies' do
+      it "should not contain the cookbook itself" do
+        # TODO: Mock
+        Cookbook.new('nginx').dependencies.collect(&:name).include?('nginx').should_not be_true
+      end
+
+      it "should compute the correct dependencies" do
+        cookbook = Cookbook.new('mysql')
+        cookbook.dependencies.should == [Cookbook.new('openssl')]
+        # Second computation is intentional, to make sure it doesn't change the dependency list.
+        cookbook.dependencies.should == [Cookbook.new('openssl')]
+      end
+    end
+
+    # TODO figure out how to test this. Stubs on classes don't clear after a test.
+    # describe '#unpack' do
+    #   it "should not unpack if it is already unpacked" do
+    #     Archive::Tar::Minitar.should_receive(:unpack).once
+    #     subject.unpack
+    #     subject.unpack
+    #   end
+    # end
+
+    describe '#groups' do
+      it "should have the default group" do
+        subject.groups.should == [:default]
+      end
+    end
+
+    describe '#add_group' do
+      it "should store strings as symbols" do
+        subject.add_group "foo"
+        subject.groups.should == [:default, :foo]
+      end
+
+      it "should not store duplicate groups" do
+        subject.add_group "bar"
+        subject.add_group "bar"
+        subject.add_group :bar
+        subject.groups.should == [:default, :bar]
+      end
+
+      it "should add multiple groups" do
+        subject.add_group "baz", "quux"
+        subject.groups.should == [:default, :baz, :quux]
+      end
+
+      it "should handle multiple groups as an array" do
+        subject.add_group ["baz", "quux"]
+        subject.groups.should == [:default, :baz, :quux]
+      end
+    end
+  end
+end