berkshelf 0.1.1

data/lib/berkshelf/cached_cookbook.rb

@@ -0,0 +1,253 @@
+require 'chef/checksum_cache'
+require 'chef/cookbook/syntax_check'
+
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class CachedCookbook
+    class << self
+      # @param [String] path
+      #   a path on disk to the location of a Cookbook downloaded by the Downloader
+      #
+      # @return [CachedCookbook]
+      #   an instance of CachedCookbook initialized by the contents found at the
+      #   given path.
+      def from_path(path)        
+        matchdata = File.basename(path.to_s).match(DIRNAME_REGEXP)
+        return nil if matchdata.nil?
+
+        cached_name = matchdata[1]
+
+        metadata = Chef::Cookbook::Metadata.new
+
+        if path.join("metadata.rb").exist?
+          metadata.from_file(path.join("metadata.rb").to_s)
+        end
+
+        new(cached_name, path, metadata)
+      end
+
+      # @param [String] filepath
+      #   a path on disk to the location of a file to checksum
+      #
+      # @return [String]
+      #   a checksum that can be used to uniquely identify the file understood
+      #   by a Chef Server.
+      def checksum(filepath)
+        Chef::ChecksumCache.generate_md5_checksum_for_file(filepath)
+      end
+    end
+
+    DIRNAME_REGEXP = /^(.+)-(\d+\.\d+\.\d+)$/
+    CHEF_TYPE = "cookbook_version".freeze
+    CHEF_JSON_CLASS = "Chef::CookbookVersion".freeze
+
+    extend Forwardable
+
+    attr_reader :cookbook_name
+    attr_reader :path
+    attr_reader :metadata
+
+    # @return [Mash]
+    #   a Mash containing Cookbook file category names as keys and an Array of Hashes
+    #   containing metadata about the files belonging to that category. This is used
+    #   to communicate what a Cookbook looks like when uploading to a Chef Server.
+    #
+    #   example:
+    #     {
+    #       :recipes => [
+    #         {
+    #           name: "default.rb",
+    #           path: "recipes/default.rb",
+    #           checksum: "fb1f925dcd5fc4ebf682c4442a21c619",
+    #           specificity: "default"
+    #         }
+    #       ]
+    #       ...
+    #       ...
+    #     }
+    attr_reader :manifest
+
+    def_delegators :@metadata, :version
+
+    def initialize(name, path, metadata)
+      @cookbook_name = name
+      @path = path
+      @metadata = metadata
+      @files = Array.new
+      @manifest = Mash.new(
+        recipes: Array.new,
+        definitions: Array.new,
+        libraries: Array.new,
+        attributes: Array.new,
+        files: Array.new,
+        templates: Array.new,
+        resources: Array.new,
+        providers: Array.new,
+        root_files: Array.new
+      )
+
+      load_files
+    end
+
+    # @return [String]
+    #   the name of the cookbook and the version number separated by a dash (-).
+    #
+    #   example:
+    #     "nginx-0.101.2"
+    def name
+      "#{cookbook_name}-#{version}"
+    end
+
+    # @return [Hash]
+    #   an hash containing the checksums and expanded file paths of all of the
+    #   files found in the instance of CachedCookbook
+    #
+    #   example:
+    #     {
+    #       "da97c94bb6acb2b7900cbf951654fea3" => "/Users/reset/.berkshelf/nginx-0.101.2/README.md"  
+    #     }
+    def checksums
+      {}.tap do |checksums|
+        files.each do |file|
+          checksums[self.class.checksum(file)] = file
+        end
+      end
+    end
+
+    # @param [Symbol] category
+    #   the category of file to generate metadata about
+    # @param [String] target
+    #   the filepath to the file to get metadata information about
+    #
+    # @return [Hash]
+    #   a Hash containing a name, path, checksum, and specificity key representing the
+    #   metadata about a file contained in a Cookbook. This metadata is used when
+    #   uploading a Cookbook's files to a Chef Server.
+    #
+    #   example:
+    #     {
+    #       name: "default.rb",
+    #       path: "recipes/default.rb",
+    #       checksum: "fb1f925dcd5fc4ebf682c4442a21c619",
+    #       specificity: "default"
+    #     }
+    def file_metadata(category, target)
+      target = Pathname.new(target)
+
+      {
+        name: target.basename.to_s,
+        path: target.relative_path_from(path).to_s,
+        checksum: self.class.checksum(target),
+        specificity: file_specificity(category, target)
+      }
+    end
+
+    # Validates that this instance of CachedCookbook points to a valid location on disk that
+    # contains a cookbook which passes a Ruby and template syntax check. Raises an error if
+    # these assertions are not true.
+    #
+    # @return [Boolean]
+    #   returns true if Cookbook is valid
+    def validate!
+      raise CookbookNotFound, "No Cookbook found at: #{path}" unless path.exist?
+
+      unless quietly { syntax_checker.validate_ruby_files }
+        raise CookbookSyntaxError, "Invalid ruby files in cookbook: #{name} (#{version})."
+      end
+      unless quietly { syntax_checker.validate_templates }
+        raise CookbookSyntaxError, "Invalid template files in cookbook: #{name} (#{version})."
+      end
+
+      true
+    end
+
+    def to_hash
+      result = manifest.dup
+      result['chef_type'] = 'cookbook_version'
+      result['name'] = name
+      result['cookbook_name'] = cookbook_name
+      result['version'] = version
+      result['metadata'] = metadata
+      result.to_hash
+    end
+
+    def to_json(*a)
+      result = self.to_hash
+      result['json_class'] = chef_json_class
+      result['frozen?'] = false
+      result.to_json(*a)
+    end
+
+    private
+
+      attr_reader :files
+
+      def chef_type
+        CHEF_TYPE
+      end
+
+      def chef_json_class
+        CHEF_JSON_CLASS
+      end
+
+      def syntax_checker
+        @syntax_checker ||= Chef::Cookbook::SyntaxCheck.new(path.to_s)
+      end
+
+      def load_files
+        load_shallow(:recipes, 'recipes', '*.rb')
+        load_shallow(:definitions, 'definitions', '*.rb')
+        load_shallow(:libraries, 'libraries', '*.rb')
+        load_shallow(:attributes, 'attributes', '*.rb')
+        load_recursively(:files, "files", "*")
+        load_recursively(:templates, "templates", "*")
+        load_recursively(:resources, "resources", "*.rb")
+        load_recursively(:providers, "providers", "*.rb")
+        load_root
+      end
+
+      def load_root
+        [].tap do |files|
+          Dir.glob(path.join('*'), File::FNM_DOTMATCH).each do |file|
+            next if File.directory?(file)
+            @files << file
+            @manifest[:root_files] << file_metadata(:root_files, file)
+          end
+        end
+      end
+
+      def load_recursively(category, category_dir, glob)
+        [].tap do |files|
+          file_spec = path.join(category_dir, '**', glob)
+          Dir.glob(file_spec, File::FNM_DOTMATCH).each do |file|
+            next if File.directory?(file)
+            @files << file
+            @manifest[category] << file_metadata(category, file)
+          end
+        end
+      end
+
+      def load_shallow(category, *path_glob)
+        [].tap do |files|
+          Dir[path.join(*path_glob)].each do |file|
+            @files << file
+            @manifest[category] << file_metadata(category, file)
+          end
+        end
+      end
+
+      # @param [Symbol] category
+      # @param [Pathname] target
+      #
+      # @return [String]
+      def file_specificity(category, target)
+        case category
+        when :files, :templates
+          relpath = target.relative_path_from(path).to_s
+          relpath.slice(/(.+)\/(.+)\/.+/, 2)
+        else
+          'default'
+        end
+      end
+  end
+end

data/lib/berkshelf/cookbook_source.rb

@@ -0,0 +1,139 @@
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class CookbookSource
+    module Location
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def download(destination)
+        raise NotImplementedError, "Function must be implemented on includer"
+      end
+    end
+
+    autoload :SiteLocation, 'berkshelf/cookbook_source/site_location'
+    autoload :GitLocation, 'berkshelf/cookbook_source/git_location'
+    autoload :PathLocation, 'berkshelf/cookbook_source/path_location'
+
+    LOCATION_KEYS = [:git, :path, :site]
+
+    attr_reader :name
+    attr_reader :version_constraint
+    attr_reader :groups
+    attr_reader :location
+    attr_reader :local_path
+
+    # TODO: describe how the options on this function work.
+    #
+    # @param [String] name
+    # @param [String] version_constraint (optional)
+    # @param [Hash] options (optional)
+    def initialize(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      name, constraint = args
+
+      @name = name
+      @version_constraint = DepSelector::VersionConstraint.new(constraint)
+      @groups = []
+      @local_path = nil
+
+      if (options.keys & LOCATION_KEYS).length > 1
+        raise ArgumentError, "Only one location key (#{LOCATION_KEYS.join(', ')}) may be specified"
+      end
+
+      options[:version_constraint] = version_constraint if version_constraint
+
+      @location = case 
+      when options[:git]
+        GitLocation.new(name, options)
+      when options[:path]
+        loc = PathLocation.new(name, options)
+        set_local_path loc.path
+        loc
+      when options[:site]
+        SiteLocation.new(name, options)
+      else
+        SiteLocation.new(name, options)
+      end
+
+      @locked_version = DepSelector::Version.new(options[:locked_version]) if options[:locked_version]
+
+      add_group(options[:group]) if options[:group]
+      add_group(:default) if groups.empty?
+      set_downloaded_status(false)
+    end
+
+    def add_group(*groups)
+      groups = groups.first if groups.first.is_a?(Array)
+      groups.each do |group|
+        group = group.to_sym
+        @groups << group unless @groups.include?(group)
+      end
+    end
+
+    # @param [String] destination
+    #   destination to download to
+    #
+    # @return [Array]
+    #   An array containing the status at index 0 and local path or error message in index 1
+    #
+    #   Example:
+    #     [ :ok, "/tmp/nginx" ]
+    #     [ :error, "Cookbook 'sparkle_motion' not found at site: http://cookbooks.opscode.com/api/v1/cookbooks" ]
+    def download(destination)
+      set_local_path location.download(destination)
+      [ :ok, local_path ]
+    rescue CookbookNotFound => e
+      set_local_path = nil
+      [ :error, e.message ]
+    end
+
+    def downloaded?
+      !local_path.nil?
+    end
+
+    def metadata
+      return nil unless local_path
+
+      cookbook_metadata = Chef::Cookbook::Metadata.new
+      cookbook_metadata.from_file(File.join(local_path, "metadata.rb"))
+      cookbook_metadata
+    end
+
+    def to_s
+      name
+    end
+
+    def has_group?(group)
+      groups.include?(group.to_sym)
+    end
+
+    def dependencies
+      return nil unless metadata
+
+      metadata.dependencies
+    end
+
+    def local_version
+      return nil unless metadata
+
+      metadata.version
+    end
+
+    def locked_version
+      @locked_version || local_version
+    end
+
+    private
+
+      def set_downloaded_status(state)
+        @downloaded_state = state
+      end
+
+      def set_local_path(path)
+        @local_path = path
+      end
+  end
+end

data/lib/berkshelf/cookbook_source/git_location.rb

@@ -0,0 +1,54 @@
+module Berkshelf
+  class CookbookSource
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class GitLocation
+      include Location
+
+      attr_accessor :uri
+      attr_accessor :branch
+
+      def initialize(name, options)
+        @name = name
+        @uri = options[:git]
+        @branch = options[:branch] || options[:ref] || options[:tag]
+      end
+
+      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}-#{self.branch}")
+
+        FileUtils.mv(tmp_clone, cb_path, :force => true)
+
+        cb_path
+      rescue Berkshelf::GitError
+        msg = "Cookbook '#{name}' not found at git: #{uri}" 
+        msg << " with branch '#{branch}'" if branch
+        raise CookbookNotFound, msg
+      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
+end

data/lib/berkshelf/cookbook_source/path_location.rb

@@ -0,0 +1,27 @@
+module Berkshelf
+  class CookbookSource
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class PathLocation
+      include Location
+
+      attr_accessor :path
+
+      def initialize(name, options = {})
+        @name = name
+        @path = File.expand_path(options[:path])
+      end
+
+      def download(destination)
+        unless File.chef_cookbook?(path)
+          raise CookbookNotFound, "Cookbook '#{name}' not found at path: '#{path}'"
+        end
+
+        path
+      end
+
+      def to_s
+        "path: '#{path}'"
+      end
+    end
+  end
+end