minimart 0.0.1

data/lib/minimart/commands/web.rb

@@ -0,0 +1,91 @@
+module Minimart
+  module Commands
+    # Web is the main entrance point for building the web interface for Minimart.
+    # This class will generate the index file to be used by Berkshelf, archived
+    # cookbooks, and HTML used to browse the available inventory.
+    class Web
+
+      # @return [String] The directory that the inventory is stored in.
+      attr_reader :inventory_directory
+
+      # @return [String] The directory to store the web output.
+      attr_reader :web_directory
+
+      # @return [String] The web endpoint where Minimart will be hosted.
+      attr_reader :web_endpoint
+
+      # @return [Boolean] Determine whether or not to generate HTML output
+      attr_reader :can_generate_html
+
+
+      # @param [Hash] opts
+      # @option opts [String] :inventory_directory The directory that the inventory is stored in.
+      # @option opts [String] :web_directory The directory to store the web output.
+      # @option opts [String] :host The web endpoint where Minimart will be hosted.
+      # @option opts [Boolean] :can_generate_html Determine whether or not to generate HTML output
+      def initialize(opts = {})
+        @inventory_directory = File.expand_path(opts[:inventory_directory])
+        @web_directory       = File.expand_path(opts[:web_directory])
+        @web_endpoint        = opts[:host]
+        @can_generate_html   = opts.fetch(:html, true)
+      end
+
+      # Generate the web output.
+      def execute!
+        make_web_directory
+        generate_universe
+        generate_html
+        print_success_message
+      end
+
+      private
+
+      attr_reader :cookbooks
+
+      def make_web_directory
+        FileUtils.mkdir_p web_directory
+      end
+
+      def generate_universe
+        Configuration.output.puts "Building the cookbook index."
+
+        generator = Minimart::Web::UniverseGenerator.new(
+          web_directory: web_directory,
+          endpoint:      web_endpoint,
+          cookbooks:     cookbooks)
+
+        generator.generate
+      end
+
+      def generate_html
+        return unless generate_html?
+
+        Configuration.output.puts "Generating Minimart HTML."
+
+        generator = Minimart::Web::HtmlGenerator.new(
+          web_directory: web_directory,
+          cookbooks:     cookbooks)
+
+        generator.generate
+      end
+
+      def cookbooks
+        @cookbooks ||= Minimart::Web::Cookbooks.new(inventory_directory: inventory_directory)
+      end
+
+      def generate_html?
+        can_generate_html
+      end
+
+      def print_success_message
+        Configuration.output.puts_green('Minimart successfully built the static web files!')
+        Configuration.output.puts_green("The static web files can be found in #{relative_web_path}")
+      end
+
+      def relative_web_path
+        File.join('.', Pathname.new(web_directory).relative_path_from(Pathname.pwd))
+      end
+
+    end
+  end
+end

data/lib/minimart/configuration.rb

@@ -0,0 +1,46 @@
+require 'minimart/output'
+
+module Minimart
+  # General configuration settings for Minimart.
+  class Configuration
+
+    class << self
+      # IO interface for minimart
+      # @return [Minimart::Output]
+      def output
+        @output || Minimart::Output.new($stdout)
+      end
+
+      # Set which IO output should use
+      # @param [IO] io
+      def output=(io)
+        @output = Minimart::Output.new(io)
+      end
+
+      def chef_server_config=(config)
+        @chef_server = config
+      end
+
+      def chef_server_config
+        (@chef_server || {}).merge(ssl: {verify: verify_ssl})
+      end
+
+      def github_config=(config)
+        @github_config = config
+      end
+
+      def github_config
+        (@github_config || {}).merge(connection_options: {ssl: {verify: verify_ssl}})
+      end
+
+      def verify_ssl
+        @verify_ssl.nil? ? true : @verify_ssl
+      end
+
+      def verify_ssl=(val)
+        @verify_ssl = val
+      end
+    end
+
+  end
+end

data/lib/minimart/cookbook.rb

@@ -0,0 +1,173 @@
+require 'ridley'
+require 'semverse'
+
+require 'minimart/web/markdown_parser'
+require 'minimart/web/template_helper'
+require 'minimart/utils/file_helper'
+
+module Minimart
+
+  # An object wrapper to get information about a cookbook.
+  class Cookbook
+    include Web::TemplateHelper
+
+    # Generate a new Minimart::Cookbook from a path
+    # @param [String] path The path to the cookbook directory
+    # @return [Minimart::Cookbook]
+    def self.from_path(path)
+      path = Minimart::Utils::FileHelper.cookbook_path_in_directory(path)
+      new (Ridley::Chef::Cookbook.from_path(path))
+    end
+
+    # @param [Ridley::Chef::Cookbok] raw_cookbook
+    def initialize(raw_cookbook)
+      @raw_cookbook = raw_cookbook
+    end
+
+    # Get the name of the cookbook
+    # @return [String]
+    def name
+      raw_cookbook.cookbook_name
+    end
+
+    # Get the version of the cookbook
+    # @return [String]
+    def version
+      raw_cookbook.version
+    end
+
+    # Return a the cookbook name, and version number separated by a dash
+    # @return [String]
+    def to_s
+      raw_cookbook.name
+    end
+
+    # Get a short description of the cookbook.
+    # @return [String]
+    def description
+      metadata.description
+    end
+
+    # Get the maintainer of the cookbook
+    # @return [String]
+    def maintainer
+      metadata.maintainer
+    end
+
+    # Get the path to the cookbook on the file system
+    # @return [String]
+    def path
+      raw_cookbook.path
+    end
+
+    # Get a URL friendly version of the cookbook version
+    # @return [String]
+    def web_friendly_version
+      version.gsub('.', '_')
+    end
+
+    # Get any dependencies that this cookbook may have
+    # @return [Hash] cookbook_name => version_requirement
+    def dependencies
+      metadata.dependencies
+    end
+
+    # Get a list of platforms this cookbook can run on
+    # @return [Array<String>]
+    def platforms
+      metadata.platforms.keys
+    end
+
+    # Get the path to the README file if one is available
+    # @return [String]
+    def readme_file
+      @readme_file ||= find_file('readme')
+    end
+
+    # Get the path to the CHANGELOG file if one is available
+    # @return [String]
+    def changelog_file
+      @changelog_file ||= find_file('changelog')
+    end
+
+    # Get the parsed Markdown content of the README
+    # @return [String]
+    def readme_content
+      @readme_content ||= Web::MarkdownParser.parse(readme_file) if readme_file
+    end
+
+    # Get the parsed Markdown content of the CHANGELOG
+    # @return [String]
+    def changelog_content
+      @changelog_content ||= Web::MarkdownParser.parse(changelog_file) if changelog_file
+    end
+
+    def to_hash
+      {
+        name:           name,
+        version:        version,
+        description:    description,
+        maintainer:     maintainer,
+        download_url:   cookbook_download_path(self),
+        url:            cookbook_path(self),
+        downloaded_at:  downloaded_at,
+        download_date:  download_date,
+        platforms:      normalized_platforms
+      }
+    end
+
+    def to_json(opts = {})
+      to_hash.to_json
+    end
+
+    # Get the time at which this cookbook was downloaded by Minimart.
+    # @return [Time]
+    def downloaded_at
+      download_metadata.downloaded_at
+    end
+
+    # Get a human friendly downlaod date of this cookbook (ex. January 1st, 2015)
+    # @return [String]
+    def download_date
+      return unless downloaded_at
+      downloaded_at.strftime('%B %d, %Y')
+    end
+
+    def <=>(other)
+      Semverse::Version.new(version) <=> Semverse::Version.new(other.version)
+    end
+
+    def satisfies_requirement?(constraint)
+      Semverse::Constraint.new(constraint).satisfies?(version)
+    end
+
+    def normalized_platforms
+      return {'question' => 'Not Specified'} if platforms.nil? || platforms.empty?
+
+      platforms.inject({}) do |memo, platform|
+        memo[platform_icon(platform)] = platform.capitalize
+        memo
+      end
+    end
+
+    # Get any metadata about how this cookbook was downloaded.
+    # @return [Minimart::Mirror::DownloadMetadata]
+    def download_metadata
+      @download_metadata ||= Minimart::Mirror::DownloadMetadata.new(self.path)
+    end
+
+    protected
+
+    attr_reader :raw_cookbook
+
+    def metadata
+      raw_cookbook.metadata
+    end
+
+    def find_file(name)
+      Dir.glob(File.join(path, '*')).find do |file|
+        File.basename(file, File.extname(file)) =~ /\A#{name}\z/i
+      end
+    end
+  end
+end

data/lib/minimart/download/cookbook.rb

@@ -0,0 +1,70 @@
+require 'octokit'
+require 'ridley'
+
+require 'minimart/utils/archive'
+require 'minimart/utils/http'
+
+module Minimart
+  module Download
+    # This class will download a cookbook from one of the inventory specified sources.
+    class Cookbook
+
+      # @return [Minimart::Mirror::SourceCookbook] The cookbook to download
+      attr_reader :cookbook
+
+      # @param [Minimart::Mirror::SourceCookbook] cookbook The cookbook to download
+      def initialize(cookbook)
+        @cookbook = cookbook
+      end
+
+      # Download the cookbook
+      # @yield Minimart::Cookbook]
+      def fetch(&block)
+        Configuration.output.puts "-- Downloading #{cookbook.name} #{cookbook.version}"
+
+        unless respond_to?("download_#{cookbook.location_type}", true)
+          raise Minimart::Error::UnknownLocationType,
+            "Minimart cannot download #{cookbook.name} because it has an unknown location type #{cookbook.location_type}"
+        end
+
+        Dir.mktmpdir do |dir|
+          send("download_#{cookbook.location_type}", dir)
+          block.call(Minimart::Cookbook.from_path(dir)) if block
+        end
+      end
+
+      private
+
+      def download_opscode(dir)
+        details = Utils::Http.get_json(cookbook.location_path, "cookbooks/#{cookbook.name}/versions/#{cookbook.web_friendly_version}")
+        get_archive(details['file'], dir)
+      end
+
+      def download_uri(dir)
+        get_archive(cookbook.location_path, dir)
+      end
+
+      def download_chef_server(dir)
+        opts = Minimart::Configuration.chef_server_config.merge(server_url: cookbook.location_path)
+
+        Ridley.open(opts) do |ridley_client|
+          ridley_client.cookbook.download(cookbook.name, cookbook.version, dir)
+        end
+      end
+
+      def download_github(dir)
+        location_path = cookbook.location_path_uri.path.gsub(/\A\//, '')
+        client        = Octokit::Client.new(Minimart::Configuration.github_config)
+        url           = client.archive_link(location_path, ref: "v#{cookbook.version}")
+
+        get_archive(url, dir)
+      end
+
+      def get_archive(url, dir)
+        archive_file = Utils::Http.get_binary("#{cookbook.name}-#{cookbook.version}", url)
+        Utils::Archive.extract_archive(archive_file, dir)
+      end
+
+    end
+  end
+end

data/lib/minimart/download/git_cache.rb

@@ -0,0 +1,60 @@
+module Minimart
+  module Download
+    # GitCache manages cloning repositories, and storing them for later access.
+    class GitCache
+
+      class << self
+        # Get the GitCache singleton instance
+        # @return [Minimart::Download::GitCache]
+        def instance
+          @instance ||= GitCache.new
+        end
+      end
+
+      def initialize
+        self.cache = {}
+      end
+
+      # Get a repository from the GitCache. This repository will be cloned, if
+      # it hasn't been already.
+      # @param [String] repo_location Any location that can be cloned by Git (Path, URL).
+      # @return [Git::Base]
+      def get_repository(repo_location)
+        cache[repo_location] ||= clone_bare_repo(repo_location)
+      end
+
+      # Get the local path to the repository passed in. This repository will be cloned,
+      # if it hasn't been already.
+      # @param [String] repo_location Any location that can be cloned by Git (Path, URL).
+      # @return [String] The path to the repository
+      def local_path_for(repo_location)
+        get_repository(repo_location).repo.path
+      end
+
+      # This method will empty the GitCache.
+      def clear
+        cache.values.each do |git|
+          FileUtils.remove_entry(git.repo.path)
+        end
+        self.cache = {}
+      end
+
+      # See if the GitCache has any reference to a repository location.
+      # @param [String] repo_location Any location that can be cloned by Git (Path, URL).
+      # @return [Boolean]
+      def has_location?(repo_location)
+        cache.has_key? repo_location
+      end
+
+      private
+
+      attr_accessor :cache
+
+      def clone_bare_repo(repo_location)
+        Configuration.output.puts "-- Cloning Git Repository From '#{repo_location}'"
+        Git.clone(repo_location, Dir.mktmpdir, bare: true)
+      end
+
+    end
+  end
+end

data/lib/minimart/download/git_repository.rb

@@ -0,0 +1,41 @@
+require 'git'
+require 'minimart/download/git_cache'
+
+module Minimart
+  module Download
+    # GitRepository manages cloning, and checking out a given Git endpoint.
+    class GitRepository
+
+      # @return [String] any location that can be cloned by Git (Path, URL).
+      attr_reader :location
+
+      # @param [String] location Any location that can be cloned by Git (Path, URL).
+      def initialize(location)
+        @location = location
+      end
+
+      # Fetch the given commit, branch, or tag.
+      # @param commitish The commit, branch, or tag to clone for the given location.
+      # @yield [Dir] Tmp directory containing the repository. This directory will be removed when the block exits.
+      def fetch(commitish, &block)
+        Dir.mktmpdir do |tmpdir|
+          result_repo = Git.clone(bare_repo_path, tmpdir)
+          result_repo.fetch(bare_repo_path, tags: true)
+          result_repo.reset_hard(bare_repo.revparse(commitish))
+          block.call(tmpdir) if block
+        end
+      end
+
+      private
+
+      def bare_repo_path
+        @bare_repo_path ||= Download::GitCache.instance.local_path_for(location)
+      end
+
+      def bare_repo
+        @bare_repo ||= Download::GitCache.instance.get_repository(location)
+      end
+
+    end
+  end
+end