berkshelf 0.3.7 → 0.4.0.rc1

data/lib/berkshelf/cookbook_source/chef_api_location.rb

@@ -0,0 +1,256 @@
+require 'uri'
+
+module Berkshelf
+  class CookbookSource
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class ChefAPILocation
+      class << self
+        # @param [String] node_name
+        #
+        # @return [Boolean]
+        def validate_node_name(node_name)
+          node_name.is_a?(String) && !node_name.empty?
+        end
+
+        # @raise [InvalidChefAPILocation]
+        #
+        # @see validate_node_name
+        def validate_node_name!(node_name)
+          unless validate_node_name(node_name)
+            raise InvalidChefAPILocation
+          end
+
+          true
+        end
+
+        # @param [String] client_key
+        #
+        # @return [Boolean]
+        def validate_client_key(client_key)
+          File.exists?(client_key)
+        end
+
+        # @raise [InvalidChefAPILocation]
+        #
+        # @see validate_client_key
+        def validate_client_key!(client_key)
+          unless validate_client_key(client_key)
+            raise InvalidChefAPILocation
+          end
+
+          true
+        end
+
+        # @param [String] uri
+        #
+        # @return [Boolean]
+        def validate_uri(uri)
+          uri =~ URI.regexp(['http', 'https'])
+        end
+
+        # @raise [InvalidChefAPILocation] if the given object is not a String containing a 
+        #   valid Chef API URI
+        #
+        # @see validate_uri
+        def validate_uri!(uri)
+          unless validate_uri(uri)
+            raise InvalidChefAPILocation, "'#{uri}' is not a valid Chef API URI."
+          end
+
+          true
+        end
+      end
+
+      include Location
+
+      location_key :chef_api
+      valid_options :node_name, :client_key
+
+      attr_reader :uri
+      attr_reader :node_name
+      attr_reader :client_key
+
+      # @param [#to_s] name
+      # @param [Solve::Constraint] version_constraint
+      # @param [Hash] options
+      #
+      # @option options [String, Symbol] :chef_api
+      #   a URL to a Chef API. Alternatively the symbol :knife can be provided
+      #   which will instantiate this location with the values found in your
+      #   knife configuration.
+      # @option options [String] :node_name
+      #   the name of the client to use to communicate with the Chef API.
+      #   Default: Chef::Config[:node_name]
+      # @option options [String] :client_key
+      #   the filepath to the authentication key for the client
+      #   Default: Chef::Config[:client_key]
+      def initialize(name, version_constraint, options = {})
+        @name = name
+        @version_constraint = version_constraint
+        @downloaded_status = false
+
+        validate_options!(options)
+
+        if options[:chef_api] == :knife
+          begin
+            Berkshelf.load_config
+          rescue KnifeConfigNotFound => e
+            raise KnifeConfigNotFound, "A Knife config is required when ':knife' is given for the value of a 'chef_api' location. #{e}"
+          end
+          @node_name  = Chef::Config[:node_name]
+          @client_key = Chef::Config[:client_key]
+          @uri        = Chef::Config[:chef_server_url]
+        else
+          @node_name  = options[:node_name]
+          @client_key = options[:client_key]
+          @uri        = options[:chef_api]
+        end
+
+        @rest = Chef::REST.new(uri, node_name, client_key)
+      end
+
+      # @param [#to_s] destination
+      #
+      # @return [Berkshelf::CachedCookbook]
+      def download(destination)
+        version, uri = target_version
+        cookbook = rest.get_rest(uri)
+
+        scratch = download_files(cookbook.manifest)
+
+        cb_path = File.join(destination, "#{name}-#{version}")
+        FileUtils.mv(scratch, cb_path, force: true)
+
+        cached = CachedCookbook.from_store_path(cb_path)
+        validate_cached(cached)
+        
+        set_downloaded_status(true)
+        cached
+      end
+
+      # Returns a hash representing the cookbook versions on at a Chef API for location's cookbook.
+      # The keys are version strings and the values are URLs to download the cookbook version.
+      #
+      # @example
+      #   { 
+      #     "0.101.2" => "https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2",
+      #     "0.101.5" => "https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.5"
+      #   }
+      #
+      # @return [Hash]
+      def versions
+        {}.tap do |versions|
+          rest.get_rest("cookbooks/#{name}").each do |name, data|
+            data["versions"].each do |version_info|
+              versions[version_info["version"]] = version_info["url"]
+            end
+          end
+        end
+      rescue Net::HTTPServerException => e
+        if e.response.code == "404"
+          raise CookbookNotFound, "Cookbook '#{name}' not found at chef_api: '#{uri}'"
+        else
+          raise
+        end
+      end
+
+      # Returns an array where the first element is a string representing the latest version of
+      # the Cookbook and the second element is the download URL for that version.
+      #
+      # @example
+      #   [ "0.101.2" => "https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2" ]
+      #
+      # @return [Array]
+      def latest_version
+        graph = Solve::Graph.new
+        versions.each do |version, url|
+          graph.artifacts(name, version)
+        end
+        graph.demands(name, ">= 0.0.0")
+
+        version = Solve.it!(graph)[name]
+
+        [ version, versions[version] ]
+      end
+
+      def to_s
+        "chef_api: '#{uri}'"
+      end
+
+      private
+
+        attr_reader :rest
+
+        # Returns an array containing the version and download URL for the cookbook version that
+        # should be downloaded for this location.
+        #
+        # @example
+        #   [ "0.101.2" => "https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2" ]
+        #
+        # @return [Array]
+        def target_version
+          if version_constraint
+            solution = self.class.solve_for_constraint(version_constraint, versions)
+            
+            unless solution
+              raise NoSolution, "No cookbook version of '#{name}' found at #{self} that would satisfy constraint (#{version_constraint})."
+            end
+
+            solution
+          else
+            latest_version
+          end
+        end
+
+        # Download all of the files in the given manifest to the given destination. If no destination
+        # is provided a temporary directory will be created and the files will be downloaded to there.
+        #
+        # @note
+        #   the manifest Hash is the same manifest that you get by sending the manifest message to
+        #   an instance of Chef::CookbookVersion.
+        #
+        # @param [Hash] manifest
+        # @param [String] destination
+        #
+        # @return [String]
+        #   the path to the directory containing the files
+        def download_files(manifest, destination = Dir.mktmpdir)
+          Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+            next unless manifest.has_key?(segment)
+            manifest[segment].each do |segment_file|
+              dest = File.join(destination, segment_file['path'].gsub('/', File::SEPARATOR))
+              FileUtils.mkdir_p(File.dirname(dest))
+              rest.sign_on_redirect = false
+              tempfile = rest.get_rest(segment_file['url'], true)
+              FileUtils.mv(tempfile.path, dest)
+            end
+          end
+
+          destination
+        end
+
+        # Validates the options hash given to the constructor.
+        #
+        # @param [Hash] options
+        #
+        # @raise [InvalidChefAPILocation] if any of the options are missing or their values do not
+        #   pass validation
+        def validate_options!(options)
+          if options[:chef_api] == :knife
+            return true
+          end
+
+          missing_options = [:node_name, :client_key] - options.keys
+
+          unless missing_options.empty?
+            missing_options.collect! { |opt| "'#{opt}'" }
+            raise InvalidChefAPILocation, "Source '#{name}' is a 'chef_api' location with a URL for it's value but is missing options: #{missing_options.join(', ')}."
+          end
+
+          self.class.validate_node_name!(options[:node_name])
+          self.class.validate_client_key!(options[:client_key])
+          self.class.validate_uri!(options[:chef_api])          
+        end
+    end
+  end
+end

data/lib/berkshelf/cookbook_source/git_location.rb

@@ -4,6 +4,9 @@ module Berkshelf
     class GitLocation
       include Location
 
+      location_key :git
+      valid_options :ref, :branch, :tag
+
       attr_accessor :uri
       attr_accessor :branch
 
@@ -11,9 +14,18 @@ module Berkshelf
       alias_method :tag, :branch
 
       # @param [#to_s] name
-      # @param [DepSelector::VersionConstraint] version_constraint
+      # @param [Solve::Constraint] version_constraint
       # @param [Hash] options
-      def initialize(name, version_constraint, options)
+      #
+      # @option options [String] :git
+      #   the Git URL to clone
+      # @option options [String] :ref
+      #   the commit hash or an alias to a commit hash to clone
+      # @option options [String] :branch
+      #   same as ref
+      # @option options [String] :tag
+      #   same as tag
+      def initialize(name, version_constraint, options = {})
         @name = name
         @version_constraint = version_constraint
         @uri = options[:git]

data/lib/berkshelf/cookbook_source/location.rb

@@ -2,11 +2,128 @@ module Berkshelf
   class CookbookSource
     # @author Jamie Winsor <jamie@vialstudios.com>
     module Location
+      module ClassMethods
+        # Register the location key for the including source location with CookbookSource
+        #
+        # @param [Symbol] key
+        def location_key(key)
+          CookbookSource.add_location_key(key, self)
+        end
+
+        # Register a valid option or multiple options with the CookbookSource class
+        #
+        # @param [Symbol] opts
+        def valid_options(*opts)
+          Array(opts).each do |opt|
+            CookbookSource.add_valid_option(opt)
+          end
+        end
+
+        # Returns an array where the first element is string representing the best version
+        # for the given constraint and the second element is the URI to where the corresponding
+        # version of the Cookbook can be downloaded from
+        #
+        # @example:
+        #   constraint = Solve::Constraint.new("~> 0.101.2")
+        #   versions = { 
+        #     "1.0.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/1_0_0",
+        #     "2.0.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/2_0_0"
+        #   }
+        #
+        #   subject.solve_for_constraint(versions, constraint) =>
+        #     [ "2.0.0", "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/2_0_0" ]
+        #
+        # @param [String, Solve::Constraint] constraint
+        #   version constraint to solve for
+        #
+        # @param [Hash] versions
+        #   a hash where the keys are a string representing a cookbook version and the values
+        #   are the download URL for the cookbook version.
+        #
+        # @return [Array, nil]
+        def solve_for_constraint(constraint, versions)
+          graph = Solve::Graph.new
+          name = "none"
+
+          versions.each do |version, uri|
+            graph.artifacts(name, version)
+          end
+
+          graph.demands(name, constraint)
+          result = Solve.it(graph)
+
+          return nil if result.nil?
+
+          version = result[name]
+
+          [ version, versions[version] ]
+        end
+      end
+
+      class << self
+        def included(base)
+          base.send :extend, ClassMethods
+        end
+
+        # Creates a new instance of a Class implementing Location with the given name and
+        # constraint. Which Class to instantiated is determined by the values in the given
+        # options Hash. Source Locations have an associated location_key registered with
+        # CookbookSource. If your options Hash contains a key matching one of these location_keys
+        # then the Class who registered that location_key will be instantiated. If you do not
+        # provide an option with a matching location_key a SiteLocation class will be
+        # instantiated.
+        #
+        # @example
+        #   Location.init("nginx", ">= 0.0.0", git: "git://github.com/RiotGames/artifact-cookbook.git") =>
+        #     instantiates a GitLocation
+        #
+        #   Location.init("nginx", ">= 0.0.0", path: "/Users/reset/code/nginx-cookbook") =>
+        #     instantiates a PathLocation
+        #
+        #   Location.init("nginx", ">= 0.0.0", site: "http://cookbooks.opscode.com/api/v1/cookbooks") =>
+        #     instantiates a SiteLocation
+        #
+        #   Location.init("nginx", ">= 0.0.0", chef_api: "https://api.opscode.com/organizations/vialstudios") =>
+        #     instantiates a ChefAPILocation
+        #
+        #   Location.init("nginx", ">= 0.0.0") =>
+        #     instantiates a SiteLocation
+        #
+        # @param [String] name
+        # @param [String, Solve::Constraint] constraint
+        # @param [Hash] options
+        #
+        # @return [SiteLocation, PathLocation, GitLocation, ChefAPILocation]
+        def init(name, constraint, options = {})
+          klass = klass_from_options(options)
+
+          klass.new(name, constraint, options)
+        end
+
+        private
+
+          def klass_from_options(options)
+            location_keys = (options.keys & CookbookSource.location_keys.keys)
+            if location_keys.length > 1
+              location_keys.collect! { |opt| "'#{opt}'" }
+              raise InternalError, "Only one location key (#{CookbookSource.location_keys.keys.join(', ')}) may be specified. You gave #{location_keys.join(', ')}."
+            end
+
+            if location_keys.empty?
+              SiteLocation
+            else
+              CookbookSource.location_keys[location_keys.first]
+            end
+          end
+      end
+
       attr_reader :name
       attr_reader :version_constraint
 
       # @param [#to_s] name
-      def initialize(name, version_constraint)
+      # @param [Solve::Constraint] version_constraint
+      # @param [Hash] options
+      def initialize(name, version_constraint, options = {})
         @name = name
         @version_constraint = version_constraint
         @downloaded_status = false
@@ -33,7 +150,7 @@ module Berkshelf
       #
       # @return [Boolean]
       def validate_cached(cached_cookbook)
-        unless version_constraint.include?(cached_cookbook.version)
+        unless version_constraint.satisfies?(cached_cookbook.version)
           raise ConstraintNotSatisfied, "A cookbook satisfying '#{name}' (#{version_constraint}) not found at #{self}"
         end
 

data/lib/berkshelf/cookbook_source/path_location.rb

@@ -4,11 +4,16 @@ module Berkshelf
     class PathLocation
       include Location
 
+      location_key :path
+
       attr_accessor :path
 
       # @param [#to_s] name
-      # @param [DepSelector::VersionConstraint] version_constraint
+      # @param [Solve::Constraint] version_constraint
       # @param [Hash] options
+      #
+      # @option options [String] :path
+      #   a filepath to the cookbook on your local disk
       def initialize(name, version_constraint, options = {})
         @name = name
         @version_constraint = version_constraint

data/lib/berkshelf/cookbook_source/site_location.rb

@@ -4,6 +4,8 @@ module Berkshelf
     class SiteLocation
       include Location
 
+      location_key :site
+
       attr_reader :api_uri
       attr_accessor :version_constraint
 
@@ -17,51 +19,21 @@ module Berkshelf
         def unpack(target, destination)
           Archive::Tar::Minitar.unpack(Zlib::GzipReader.new(File.open(target, 'rb')), destination)
         end
-
-        # @param [DepSelector::VersionConstraint] constraint
-        #   version constraint to solve for
-        #
-        # @param [Hash] versions
-        #   a hash where the keys are a DepSelector::Version representing a Cookbook version
-        #   number and their values are the URI the Cookbook of the corrosponding version can
-        #   be downloaded from. This format is also the output of the #versions function on 
-        #   instances of this class.
-        #
-        #   Example:
-        #       { 
-        #         0.101.2 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2",
-        #         0.101.0 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_0",
-        #         0.100.2 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_2",
-        #         0.100.0 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_0"
-        #       }
-        #
-        # @return [Array, nil]
-        #   an array where the first element is a DepSelector::Version representing the best version
-        #   for the given constraint and the second element is the URI to where the corrosponding
-        #   version of the Cookbook can be downloaded from
-        #
-        #   Example:
-        #       [ 0.101.2 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2" ]
-        def solve_for_constraint(constraint, versions)
-          versions.each do |version, uri|
-            if constraint.include?(version)
-              return [ version, uri ]
-            end
-          end
-
-          nil
-        end
       end
 
       # @param [#to_s] name
-      # @param [DepSelector::VersionConstraint] version_constraint
+      # @param [Solve::Constraint] version_constraint
       # @param [Hash] options
+      #
+      # @option options [String] :site
+      #   a URL pointing to a community API endpoint
       def initialize(name, version_constraint, options = {})
         options[:site] ||= OPSCODE_COMMUNITY_API
 
         @name = name
         @version_constraint = version_constraint
         @api_uri = options[:site]
+        @rest = Chef::REST.new(api_uri, false, false)
       end
 
       # @param [#to_s] destination
@@ -70,6 +42,7 @@ module Berkshelf
       def download(destination)
         version, uri = target_version
         remote_file = rest.get_rest(uri)['file']
+
         downloaded_tf = rest.get_rest(remote_file, true)
 
         dir = Dir.mktmpdir
@@ -85,52 +58,26 @@ module Berkshelf
         cached
       end
 
-      # @return [Array]
-      #   an Array where the first element is a DepSelector::Version representing the latest version of
-      #   the Cookbook and the second element is the URI to where the corrosponding version of the
-      #   Cookbook can be downloaded from
+      # Returns a hash of all the cookbook versions found at communite site URL for the cookbook
+      # name of this location.
       #
-      #   Example:
-      #       [ 0.101.2, "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2" ]
-      def version(version_string)
-        quietly {
-          result = rest.get_rest("#{name}/versions/#{uri_escape_version(version_string)}")
-          dep_ver = DepSelector::Version.new(result['version'])
-
-          [ dep_ver, result['file'] ]
-        }
-      rescue Net::HTTPServerException => e
-        if e.response.code == "404"
-          raise CookbookNotFound, "Cookbook name: '#{name}' version: '#{version_string}' not found at site: '#{api_uri}'"
-        else
-          raise
-        end
-      end
-
-      # @return [Hash]
-      #   a hash where the keys are a DepSelector::Version representing a Cookbook version
-      #   number and their values are the URI the Cookbook of the corrosponding version can
-      #   be downloaded from
+      # @example
+      #   { 
+      #     "0.101.2" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2",
+      #     "0.101.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_0"
+      #   }
       #
-      #   Example:
-      #       { 
-      #         0.101.2 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2",
-      #         0.101.0 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_0",
-      #         0.100.2 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_2",
-      #         0.100.0 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_100_0"
-      #       }
+      # @return [Hash]
+      #   a hash representing the cookbook versions on at a Chef API for location's cookbook.
+      #   The keys are version strings and the values are URLs to download the cookbook version.
       def versions
-        versions = Hash.new
-        quietly {
+        {}.tap do |versions|
           rest.get_rest(name)['versions'].each do |uri|
-            version_string = version_from_uri(File.basename(uri))
-            version = DepSelector::Version.new(version_string)
+            version = version_from_uri(File.basename(uri))
 
             versions[version] = uri
           end
-        }
-
-        versions
+        end
       rescue Net::HTTPServerException => e
         if e.response.code == "404"
           raise CookbookNotFound, "Cookbook '#{name}' not found at site: '#{api_uri}'"
@@ -139,20 +86,19 @@ module Berkshelf
         end
       end
 
-      # @return [Array]
-      #   an array where the first element is a DepSelector::Version representing the latest version of
-      #   the Cookbook and the second element is the URI to where the corrosponding version of the
-      #   Cookbook can be downloaded from
+      # Returns the latest version of the cookbook and it's download link.
       #
-      #   Example:
-      #       [ 0.101.2 => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2" ]
+      # @example
+      #   [ "0.101.2" => "https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2" ]
+      #
+      # @return [Array]
+      #   an array containing the version and download URL for the cookbook version that
+      #   should be downloaded for this location.
       def latest_version
         quietly {
           uri = rest.get_rest(name)['latest_version']
-          version_string = version_from_uri(uri)
-          dep_ver = DepSelector::Version.new(version_string)
 
-          [ dep_ver, uri ]
+          [ version_from_uri(uri), uri ]
         }
       rescue Net::HTTPServerException => e
         if e.response.code == "404"
@@ -162,20 +108,13 @@ module Berkshelf
         end
       end
 
-      def api_uri=(uri)
-        @rest = nil
-        @api_uri = uri
-      end
-
       def to_s
         "site: '#{api_uri}'"
       end
 
       private
 
-        def rest
-          @rest ||= Chef::REST.new(api_uri, false, false)
-        end
+        attr_reader :rest
 
         def uri_escape_version(version)
           version.gsub('.', '_')
@@ -185,27 +124,19 @@ module Berkshelf
           File.basename(latest_version).gsub('_', '.')
         end
 
-        # @return [Array]
-        #   an Array where the first element is a DepSelector::Version and the second element is
-        #   the URI to where the corrosponding version of the Cookbook can be downloaded from.
-        #
-        #
-        #   The version is determined by the value of the version_constraint attribute of this
-        #   instance of SiteLocation:
+        # Returns an array containing the version and download URL for the cookbook version that
+        # should be downloaded for this location.
         #
-        #   If it is not set: the latest_version of the Cookbook will be returned
+        # @example
+        #   [ "0.101.2" => "https://api.opscode.com/organizations/vialstudios/cookbooks/nginx/0.101.2" ]
         #
-        #   If it is set: the return value will be determined by the version_constraint and the 
-        #     available versions will be solved
-        #
-        #   Example:
-        #       [ 0.101.2, "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2" ]
+        # @return [Array]
         def target_version
           if version_constraint
             solution = self.class.solve_for_constraint(version_constraint, versions)
             
             unless solution
-              raise NoSolution, "No cookbook version of '#{name}' found at '#{api_uri}' that would satisfy constraint (#{version_constraint})."
+              raise NoSolution, "No cookbook version of '#{name}' found at #{self} that would satisfy constraint (#{version_constraint})."
             end
 
             solution