berkshelf 0.4.0.rc4 → 0.4.0

data/lib/berkshelf/locations/chef_api_location.rb

@@ -0,0 +1,252 @@
+module Berkshelf
+  # @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

data/lib/berkshelf/locations/git_location.rb

@@ -0,0 +1,76 @@
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class GitLocation
+    include Location
+
+    location_key :git
+    valid_options :ref, :branch, :tag
+
+    attr_accessor :uri
+    attr_accessor :branch
+
+    alias_method :ref, :branch
+    alias_method :tag, :branch
+
+    # @param [#to_s] name
+    # @param [Solve::Constraint] version_constraint
+    # @param [Hash] 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]
+      @branch = options[:branch] || options[:ref] || options[:tag]
+
+      Git.validate_uri!(@uri)
+    end
+
+    # @param [#to_s] destination
+    #
+    # @return [Berkshelf::CachedCookbook]
+    def download(destination)
+      tmp_clone = Dir.mktmpdir
+      ::Berkshelf::Git.clone(uri, tmp_clone)
+      ::Berkshelf::Git.checkout(tmp_clone, branch) if branch
+      unless branch
+        self.branch = ::Berkshelf::Git.rev_parse(tmp_clone)
+      end
+
+      unless File.chef_cookbook?(tmp_clone)
+        msg = "Cookbook '#{name}' not found at git: #{uri}" 
+        msg << " with branch '#{branch}'" if branch
+        raise CookbookNotFound, msg
+      end
+
+      cb_path = File.join(destination, "#{self.name}-#{Git.rev_parse(tmp_clone)}")
+      FileUtils.rm_rf(cb_path)
+      FileUtils.mv(tmp_clone, cb_path, force: true)
+              
+      cached = CachedCookbook.from_store_path(cb_path)
+      validate_cached(cached)
+
+      set_downloaded_status(true)
+      cached
+    end
+
+    def to_s
+      s = "git: '#{uri}'"
+      s << " with branch: '#{branch}'" if branch
+      s
+    end
+
+    private
+
+      def git
+        @git ||= Berkshelf::Git.new(uri)
+      end
+  end
+end

data/lib/berkshelf/locations/path_location.rb

@@ -0,0 +1,38 @@
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class PathLocation
+    include Location
+
+    location_key :path
+
+    attr_accessor :path
+
+    # @param [#to_s] name
+    # @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
+      @path = File.expand_path(options[:path])
+      set_downloaded_status(true)
+    end
+
+    # @param [#to_s] destination
+    #
+    # @return [Berkshelf::CachedCookbook]
+    def download(destination)
+      cached = CachedCookbook.from_path(path)
+      validate_cached(cached)
+
+      set_downloaded_status(true)
+      cached
+    end
+
+    def to_s
+      "path: '#{path}'"
+    end
+  end
+end

data/lib/berkshelf/locations/site_location.rb

@@ -0,0 +1,150 @@
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class SiteLocation
+    include Location
+
+    location_key :site
+
+    attr_reader :api_uri
+    attr_accessor :version_constraint
+
+    class << self
+      # @param [String] target
+      #   file path to the tar.gz archive on disk
+      # @param [String] destination
+      #   file path to extract the contents of the target to
+      def unpack(target, destination)
+        Archive::Tar::Minitar.unpack(Zlib::GzipReader.new(File.open(target, 'rb')), destination)
+      end
+    end
+
+    # @param [#to_s] name
+    # @param [Solve::Constraint] version_constraint
+    # @param [Hash] options
+    #
+    # @option options [String, Symbol] :site
+    #   a URL pointing to a community API endpoint. Alternatively the symbol :opscode can
+    #   be provided to initialize a SiteLocation pointing to the Opscode Community Site.
+    def initialize(name, version_constraint, options = {})
+      @name = name
+      @version_constraint = version_constraint
+
+      @api_uri = if options[:site].nil? || options[:site] == :opscode
+        Location::OPSCODE_COMMUNITY_API
+      else
+        options[:site]
+      end
+
+      @rest = Chef::REST.new(api_uri, false, false)
+    end
+
+    # @param [#to_s] destination
+    #
+    # @return [Berkshelf::CachedCookbook]
+    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
+      cb_path = File.join(destination, "#{name}-#{version}")
+
+      self.class.unpack(downloaded_tf.path, dir)
+      FileUtils.mv(File.join(dir, name), cb_path, force: true)
+
+      cached = CachedCookbook.from_store_path(cb_path)
+      validate_cached(cached)
+      
+      set_downloaded_status(true)
+      cached
+    end
+
+    # 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",
+    #     "0.101.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_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
+      {}.tap do |versions|
+        rest.get_rest(name)['versions'].each do |uri|
+          version = version_from_uri(File.basename(uri))
+
+          versions[version] = uri
+        end
+      end
+    rescue Net::HTTPServerException => e
+      if e.response.code == "404"
+        raise CookbookNotFound, "Cookbook '#{name}' not found at site: '#{api_uri}'"
+      else
+        raise
+      end
+    end
+
+    # Returns the latest version of the cookbook and it's download link.
+    #
+    # @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_from_uri(uri), uri ]
+      }
+    rescue Net::HTTPServerException => e
+      if e.response.code == "404"
+        raise CookbookNotFound, "Cookbook '#{name}' not found at site: '#{api_uri}'"
+      else
+        raise
+      end
+    end
+
+    def to_s
+      "site: '#{api_uri}'"
+    end
+
+    private
+
+      attr_reader :rest
+
+      def uri_escape_version(version)
+        version.gsub('.', '_')
+      end
+
+      def version_from_uri(latest_version)
+        File.basename(latest_version).gsub('_', '.')
+      end
+
+      # 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
+  end
+end