berkshelf 0.3.7 → 0.4.0.rc1

data/lib/berkshelf/cookbook_store.rb

@@ -3,9 +3,6 @@ require 'fileutils'
 module Berkshelf
   # @author Jamie Winsor <jamie@vialstudios.com>
   class CookbookStore
-    include DepSelector
-    include DepSelector::Exceptions
-
     attr_reader :storage_path
 
     # Create a new instance of CookbookStore with the given
@@ -69,27 +66,25 @@ module Berkshelf
     # constraint. Nil is returned if no matching CachedCookbook is found.
     #
     # @param [#to_s] name
-    # @param [DepSelector::VersionConstraint] constraint
+    # @param [Solve::Constraint] constraint
     #
     # @return [Berkshelf::CachedCookbook, nil]
     def satisfy(name, constraint)
-      graph                = DependencyGraph.new
-      selector             = Selector.new(graph)
-      package              = graph.package(name)
-      solution_constraints = [ SolutionConstraint.new(graph.package(name), constraint) ]
+      graph = Solve::Graph.new
+      cookbooks(name).each { |cookbook| graph.artifacts(name, cookbook.version) }
+      graph.demands(name, constraint)
 
-      cookbooks(name).each { |cookbook| package.add_version(Version.new(cookbook.version)) }
-      name, version = quietly { selector.find_solution(solution_constraints).first }
+      name, version = Solve.it!(graph).first
       
       cookbook(name, version)
-    rescue InvalidSolutionConstraints, NoSolutionExists
+    rescue Solve::NoSolutionError
       nil
     end
 
     private
 
       def initialize_filesystem
-        FileUtils.mkdir_p(storage_path, :mode => 0755)
+        FileUtils.mkdir_p(storage_path, mode: 0755)
       end
   end
 end

data/lib/berkshelf/dsl.rb

@@ -32,7 +32,7 @@ module Berkshelf
         metadata.name
       end
 
-      source = CookbookSource.new(name, :path => File.dirname(metadata_file))
+      source = CookbookSource.new(name, path: File.dirname(metadata_file))
       add_source(source)
     end
   end

data/lib/berkshelf/errors.rb

@@ -11,6 +11,7 @@ module Berkshelf
     alias_method :message, :to_s
   end
 
+  class InternalError < BerkshelfError; status_code(99); end
   class BerksfileNotFound < BerkshelfError; status_code(100); end
   class NoVersionForConstraints < BerkshelfError; status_code(101); end
   class DownloadFailure < BerkshelfError; status_code(102); end
@@ -58,4 +59,5 @@ module Berkshelf
   end
 
   class ConstraintNotSatisfied < BerkshelfError; status_code(111); end
+  class InvalidChefAPILocation < BerkshelfError; status_code(112); end
 end

data/lib/berkshelf/init_generator.rb

@@ -12,16 +12,16 @@ module Berkshelf
     include Thor::Actions
 
     argument :path,
-      :type => :string,
-      :required => true
+      type: :string,
+      required: true
 
     class_option :metadata_entry,
-      :type => :boolean,
-      :default => false
+      type: :boolean,
+      default: false
 
     class_option :chefignore,
-      :type => :boolean,
-      :default => false
+      type: :boolean,
+      default: false
 
     def generate
       target_path = File.expand_path(path)

data/lib/berkshelf/resolver.rb

@@ -2,16 +2,14 @@ module Berkshelf
   # @author Jamie Winsor <jamie@vialstudios.com>
   class Resolver
     extend Forwardable
-    include DepSelector
 
-    def_delegator :@graph, :package
-    def_delegator :@graph, :packages
+    attr_reader :graph
 
     # @param [Downloader] downloader
     # @param [Array<CookbookSource>, CookbookSource] sources
     def initialize(downloader, sources = Array.new)
       @downloader = downloader
-      @graph = DependencyGraph.new
+      @graph = Solve::Graph.new
       @sources = Hash.new
 
       # Dependencies need to be added AFTER the sources. If they are
@@ -46,8 +44,7 @@ module Berkshelf
       set_source(source)
       use_source(source) || install_source(source)
 
-      package = add_package(source.name)
-      package_version = add_version(package, Version.new(source.cached_cookbook.version))
+      graph.artifacts(source.name, source.cached_cookbook.version)
       
       if include_dependencies
         add_source_dependencies(source)
@@ -84,7 +81,11 @@ module Berkshelf
     #
     # @return [Array<Berkshelf::CachedCookbook>]
     def resolve
-      solution = quietly { selector.find_solution(solution_constraints) }
+      graph.artifacts.each do |artifact|
+        graph.demands(artifact.name)
+      end
+
+      solution = Solve.it!(graph)
 
       [].tap do |cached_cookbooks|
         solution.each do |name, version|
@@ -114,7 +115,6 @@ module Berkshelf
     private
 
       attr_reader :downloader
-      attr_reader :graph
 
       # @param [CookbookSource] source
       def set_source(source)
@@ -164,31 +164,5 @@ module Berkshelf
 
         true
       end
-
-      def selector
-        Selector.new(graph)
-      end
-
-      def solution_constraints
-        constraints = graph.packages.collect do |name, package|
-          SolutionConstraint.new(package)
-        end
-      end
-
-      # @param [String] name
-      #   name of the package to add to the graph
-      def add_package(name)
-        graph.package(name)
-      end
-
-      # Add a version to a package
-      #
-      # @param [DepSelector::Package] package
-      #   the package to add a version to
-      # @param [DepSelector::Version] version
-      #   the version to add the the package
-      def add_version(package, version)
-        package.add_version(version)
-      end
   end
 end

data/lib/berkshelf/uploader.rb

@@ -71,7 +71,7 @@ module Berkshelf
           memo
         end
         
-        rest.post_rest("sandboxes", :checksums => massaged_sums)
+        rest.post_rest("sandboxes", checksums: massaged_sums)
       end
 
       def commit_sandbox(sandbox)
@@ -107,13 +107,13 @@ module Berkshelf
         file_contents = File.open(file, "rb") {|f| f.read}
 
         sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(
-          :http_method => :put,
-          :path        => URI.parse(url).path,
-          :body        => file_contents,
-          :timestamp   => timestamp,
-          :user_id     => rest.client_name
+          http_method: :put,
+          path: URI.parse(url).path,
+          body: file_contents,
+          timestamp: timestamp,
+          user_id: rest.client_name
         )
-        headers = { 'content-type' => 'application/x-binary', 'content-md5' => checksum64, :accept => 'application/json' }
+        headers = { 'content-type' => 'application/x-binary', 'content-md5' => checksum64, accept: 'application/json' }
         headers.merge!(sign_obj.sign(OpenSSL::PKey::RSA.new(rest.signing_key)))
 
         begin

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "0.3.7"
+  VERSION = "0.4.0.rc1"
 end

data/spec/fixtures/reset.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAyyUMqrTh1IzKOyE0fvXEWC7m0AdMI8/dr9JJMUKtK9vhhP0w
+rm6m95GoybFM2IRryukFsAxpcir3M1ungTU3Smq4MshhMJ7H9FbvZVfQoknTbCsR
+w6scg2fBepxT2+fcGRufr8nAh92M3uUkN9bMMTAkt18D4br6035YvdmvHDJERxYq
+ByA/720AdI9VNSIvw+x8oqsIkXLEdF6dgT9MpG5iWZT66pbFsnNZpRrd4/bFNWBY
++13aOqdmjiTL08/EdgQFKMT5qimpos1TuQhA7mwInOjQgzVu9uCDkMiYejaLbUz0
+lGyS8y4uxu6z2hA900Jg/z+JJuXymH5QAX3GZQIDAQABAoIBAQCtFXkwbYPI1Nht
+/wG6du5+8B9K+hy+mppY9wPTy+q+Zs9Ev3Fd/fuXDm1QxBckl9c8AMUO1dR2KPOM
+t7gFl/DvH/SnmCFvCqp1nijFIUgrLlnMXPn6zG0z7RBlxpKQ2IGohufNIEpBuNwR
+Ag2U4hgChPGTp4ooJ2cVEh7MS5AupYPDbC62dWEdW68aRTWhh2BCGAWBb6s16yl9
+aZ7+OcxW2eeRJVbRfLkLQEDutJZi5TfOEn5QPc86ZgxcCmnvwulnpnhpz6QCkgQt
+OP/+KRqDhWSDVCFREVT30fUIj1EWvK7NFWASZQxueZStuIvMEKeFebYfrbHxRFzJ
+UmaxJnWVAoGBAPbKLpeky6ClccBaHHrCgjzakoDfGgyNKDQ9g753lJxB8nn7d9X4
+HQpkWpfqAGFRZp1hI2H+VxyUXLh2Ob5OUeTm0OZJll35vycOaQEtfgIScXTcvzn0
+16J9eX2YY4wIHEEMh85nKk8BEGgiNP5nuEviHocCeYXoi/Zq3+qj6v63AoGBANK5
+4nyi6LBQFs1CUc7Sh7vjtOE3ia7KeRmOr7gS6QhS3iK3Oa8FzBLJ6ETjN2a9Bw8N
+cF7I/+cr4s7DUJjxdb53D/J6TVSYORNNCUVnpF/uB2LqqdXDYmpO0PvFkXFoYTnJ
+kaLAN8uCoLKr6JH9tq3DfXIfDIHiZ+BOIvI070fDAoGBAMDyzEDFmGruTyRLj66u
++rJnVVmqlKwxhLhrS+CTj74nlVOnt0a0KMhiM65IRqnPwcHUG5zXBPaUTHXwAS93
+/nFPwQ37hLPOupPnoVNJZRZrowbyPBQtCJbDMURv64ylHqoBCQDoCd0hANnZvMMX
+BrFVhfaaibaXXS542r6SD/27AoGAECadHE5kJTdOOBcwK/jo3Fa8g1J9Y/8yvum3
+wBT69V9clS6T5j08geglvDnqAh7UzquKBEnFi1NKw+wmXkKLcrivaTdEfApavYb3
+AfHKoGue907jC3Y5Mcquq81ds2J7qTEwz1eKLzfo1yjj32ShvrmwALIuhDn1GjUC
+6qtx938CgYEApEqvu0nocR1jmVVlLe5uKQBj949dh6NGq0R5Lztz6xufaTYzMC3d
+AZG9XPPjRqSLs+ylSXJpwHEwoeyLFDaJcO+GgW1/ut4MC2HppOx6aImwDdXMHUWR
+KYGIFF4AU/IYoBcanAm4s078EH/Oz01B2c7tR2TqabisPgLYe7PXSCw=
+-----END RSA PRIVATE KEY-----

data/spec/knife.rb.sample

@@ -0,0 +1,12 @@
+current_dir = File.expand_path(File.dirname(__FILE__))
+
+log_level                :info
+log_location             STDOUT
+node_name                "berkshelf"
+client_key               "#{current_dir}/berkshelf.pem"
+validation_client_name   "chef-validator"
+validation_key           "#{current_dir}/chef-validator.pem"
+chef_server_url          "http://localhost:4000"
+cache_type               'BasicFile'
+cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )
+cookbook_path            []

data/spec/spec_helper.rb

@@ -22,10 +22,11 @@ Spork.prefork do
   RSpec.configure do |config|
     config.include Berkshelf::RSpec::FileSystemMatchers
     config.include JsonSpec::Helpers
+    config.include Berkshelf::RSpec::ChefAPI
     
     config.mock_with :rspec
     config.treat_symbols_as_metadata_keys_with_true_values = true
-    config.filter_run :focus => true
+    config.filter_run focus: true
     config.run_all_when_everything_filtered = true
 
     config.around do |example|
@@ -85,6 +86,8 @@ Spork.prefork do
     FileUtils.rm_rf(tmp_path)
     FileUtils.mkdir_p(tmp_path)
   end
+
+  Berkshelf::RSpec::Knife.load_knife_config(File.join(APP_ROOT, 'spec/knife.rb'))
 end
 
 Spork.each_run do

data/spec/support/chef_api.rb

@@ -5,6 +5,33 @@ require 'chef/cookbook_version'
 module Berkshelf
   module RSpec
     module ChefAPI
+      # Return an array of Hashes containing cookbooks and their information
+      #
+      # @return [Array]
+      def get_cookbooks
+        rest.get_rest("cookbooks")
+      end
+
+      def upload_cookbook(path)
+        cached = CachedCookbook.from_store_path(path)
+        uploader.upload!(cached)
+      end
+
+      # Remove all versions of all cookbooks from the Chef Server defined in your
+      # Knife config.
+      def purge_cookbooks
+        get_cookbooks.each do |name, info|
+          info["versions"].each do |version_info|
+            rest.delete_rest("cookbooks/#{name}/#{version_info["version"]}?purge=true")
+          end
+        end
+      end
+
+      # Remove the version of the given cookbook from the Chef Server defined
+      # in your Knife config.
+      #
+      # @param [#to_s] name
+      # @param [#to_s] version
       def purge_cookbook(name, version)
         rest.delete_rest("cookbooks/#{name}/#{version}?purge=true")
       rescue Net::HTTPServerException => e
@@ -57,6 +84,7 @@ EOF
         end
 
         File.write(cookbook_path.join("metadata.rb"), metadata)
+        cookbook_path
       end
 
       private
@@ -64,6 +92,10 @@ EOF
         def rest
           quietly { Chef::REST.new(Chef::Config[:chef_server_url]) }
         end
+
+        def uploader
+          @uploader ||= Berkshelf::Uploader.new(Chef::Config[:chef_server_url])
+        end
     end
   end
 end

data/spec/support/knife.rb

@@ -0,0 +1,18 @@
+require 'chef/config'
+
+module Berkshelf
+  module RSpec
+    module Knife
+      class << self
+        def load_knife_config(path)
+          if File.exist?(path)
+            Chef::Config.from_file(path)
+            ENV["CHEF_CONFIG"] = path
+          else
+            raise "Cannot continue; '#{path}' must exist and have testing credentials."
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/cookbook_source/chef_api_location_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe CookbookSource::ChefAPILocation do
+    let(:test_chef_api) { "https://chefserver:8081" }
+
+    describe "ClassMethods" do
+      subject { CookbookSource::ChefAPILocation }
+      let(:valid_uri) { test_chef_api }
+      let(:invalid_uri) { "notauri" }
+      let(:constraint) { double('constraint') }
+
+      describe "::initialize" do
+        let(:node_name) { "reset" }
+        let(:client_key) { fixtures_path.join("reset.pem").to_s }
+
+        before(:each) do
+          @location = subject.new("nginx",
+            constraint,
+            chef_api: test_chef_api,
+            node_name: node_name,
+            client_key: client_key
+          )
+        end
+
+        it "sets the uri attribute to the value of the chef_api option" do
+          @location.uri.should eql(test_chef_api)
+        end
+
+        it "sets the node_name attribute to the value of the node_name option" do
+          @location.node_name.should eql(node_name)
+        end
+
+        it "sets the client_key attribute to the value of the client_key option" do
+          @location.client_key.should eql(client_key)
+        end
+
+        it "sets the downloaded status to false" do
+          @location.should_not be_downloaded
+        end
+
+        context "when an invalid Chef API URI is given" do
+          it "raises InvalidChefAPILocation" do
+            lambda {
+              subject.new("nginx", constraint, chef_api: invalid_uri, node_name: node_name, client_key: client_key)
+            }.should raise_error(InvalidChefAPILocation, "'notauri' is not a valid Chef API URI.")
+          end
+        end
+
+        context "when no option for node_name is supplied" do
+          it "raises InvalidChefAPILocation" do
+            lambda {
+              subject.new("nginx", constraint, chef_api: invalid_uri, client_key: client_key)
+            }.should raise_error(InvalidChefAPILocation)
+          end
+        end
+
+        context "when no option for client_key is supplied" do
+          it "raises InvalidChefAPILocation" do
+            lambda {
+              subject.new("nginx", constraint, chef_api: invalid_uri, node_name: node_name)
+            }.should raise_error(InvalidChefAPILocation)
+          end
+        end
+
+        context "given the symbol :knife for the value of chef_api:" do
+          before(:each) { @loc = subject.new("nginx", constraint, chef_api: :knife) }
+
+          it "uses the value of Chef::Config[:chef_server_url] for the uri attribute" do
+            @loc.uri.should eql(Chef::Config[:chef_server_url])
+          end
+
+          it "uses the value of Chef::Config[:node_name] for the node_name attribute" do
+            @loc.node_name.should eql(Chef::Config[:node_name])
+          end
+
+          it "uses the value of Chef::Config[:client_key] for the client_key attribute" do
+            @loc.client_key.should eql(Chef::Config[:client_key])
+          end
+
+          it "attempts to load the config file with no arguments" do
+            Berkshelf.should_receive(:load_config).with(no_args)
+
+            subject.new("nginx", constraint, chef_api: :knife)
+          end
+        end
+      end
+
+      describe "::validate_uri" do
+        it "returns false if the given URI is invalid" do
+          subject.validate_uri(invalid_uri).should be_false
+        end
+
+        it "returns true if the given URI is valid" do
+          subject.validate_uri(valid_uri).should be_true
+        end
+      end
+
+      describe "::validate_uri!" do
+        it "raises InvalidChefAPILocation if the given URI is invalid" do
+          lambda {
+            subject.validate_uri!(invalid_uri)
+          }.should raise_error(InvalidChefAPILocation, "'notauri' is not a valid Chef API URI.")
+        end
+
+        it "returns true if the given URI is valid" do
+          subject.validate_uri!(valid_uri).should be_true
+        end
+      end
+    end
+
+    subject do
+      loc = CookbookSource::ChefAPILocation.new("nginx",
+        double('constraint', satisfies?: true),
+        chef_api: :knife
+      )
+    end
+
+    let(:rest) { double('rest') }
+
+    before(:each) do
+      subject.stub(:rest) { rest }
+    end
+
+    describe "#download" do
+      let(:latest) { ["0.101.2", "http://chef/cookbook/nginx/0.101.2"] }
+      let(:versions) do
+        versions = {
+          "#{subject.name}" => {
+            "versions" => [
+              {
+                "url" => "https://api.opscode.com/organizations/vialstudios/cookbooks/#{subject.name}/0.101.2",
+                "version" => "0.101.2"
+              },
+              {
+                "url" => "https://api.opscode.com/organizations/vialstudios/cookbooks/#{subject.name}/0.99.0",
+                "version" => "0.99.0"
+              }
+            ],
+            "url" => "https://api.opscode.com/organizations/vialstudios/cookbooks/#{subject.name}"
+          }
+        }
+      end
+
+      before(:each) do
+        subject.stub(:latest_version) { latest }
+        rest.should_receive(:get_rest).with("cookbooks/#{subject.name}").and_return(versions)
+      end
+
+      context "given a constraint that matches an available cookbook" do
+        before(:each) do
+          cookbook_version = double('cookbook-version')
+          cookbook_version.stub(:manifest).and_return({})
+          subject.stub(:version_constraint) { Solve::Constraint.new("= 0.99.0") }
+          rest.should_receive(:get_rest).with("https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.99.0").and_return(cookbook_version)
+          subject.should_receive(:download_files).with(cookbook_version.manifest).and_return(
+            generate_cookbook(Dir.mktmpdir, subject.name, "0.99.0")
+          )
+        end
+
+        it "returns an instance of Berkshelf::CachedCookbook" do
+          subject.download(tmp_path).should be_a(Berkshelf::CachedCookbook)
+        end
+
+        it "sets the downloaded status to true" do
+          subject.download(tmp_path)
+
+          subject.should be_downloaded
+        end
+      end
+
+      context "given a wildcard '>= 0.0.0' version constraint is specified" do
+        before(:each) do
+          subject.stub(:version_constraint) { Solve::Constraint.new(">= 0.0.0") }
+        end
+
+        it "downloads the manifest of the latest cookbook version of the cookbook" do
+          cookbook_version = double('cookbook-version')
+          cookbook_version.stub(:manifest).and_return({})
+          rest.should_receive(:get_rest).with("https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2").and_return(cookbook_version)
+          subject.should_receive(:download_files).with(cookbook_version.manifest).and_return(
+            generate_cookbook(Dir.mktmpdir, subject.name, subject.latest_version[0])
+          )
+
+          subject.download(tmp_path)
+        end
+      end
+    end
+
+    describe "#versions" do
+      before(:each) do
+        rest = double('rest')
+        subject.stub(:rest) { rest }
+        response = {"nginx"=>{"versions"=>[{"url"=>"https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2", "version"=>"0.101.2"}], "url"=>"https://api.opscode.com/organizations/vialstudios/cookbooks/nginx"}}
+        rest.stub(:get_rest).and_return(response)
+      end
+
+      it "returns a hash containing a string containing the version number of each cookbook version as the keys" do
+        subject.versions.should have_key("0.101.2")
+      end
+
+      it "returns a hash containing a string containing the download URL for each cookbook version as the values" do
+        subject.versions["0.101.2"].should eql("https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2")
+      end
+    end
+
+    describe "#latest_version" do
+      before(:each) do
+        subject.stub(:versions).and_return(
+          "0.0.1" => "https://chef/nginx/0.0.1",
+          "1.0.0" => "https://chef/nginx/1.0.0",
+          "0.100.0" => "https://chef/nginx/0.100.0"
+        )
+      end
+
+      it "returns an array with two elements" do
+        subject.latest_version.should be_a(Array)
+        subject.latest_version.should have(2).items
+      end
+
+      it "returns an array containing the latest version at index 0" do
+        subject.latest_version[0].should eql("1.0.0")
+      end
+
+      it "returns an array containing the URL to the latest version at index 1" do
+        subject.latest_version[1].should eql("https://chef/nginx/1.0.0")
+      end
+    end
+
+    describe "#to_s" do
+      subject do
+        CookbookSource::ChefAPILocation.new('nginx',
+          double('constraint'),
+          chef_api: :knife
+        )
+      end
+
+      it "returns a string containing the location key and the Chef API URI" do
+        subject.to_s.should eql("chef_api: '#{Chef::Config[:chef_server_url]}'")
+      end
+    end
+  end
+end