minimart 0.0.1

data/lib/minimart/mirror/source.rb

@@ -0,0 +1,57 @@
+require 'minimart/utils/http'
+
+module Minimart
+  module Mirror
+
+    # Source represents a single remote source to fetch cookbooks from.
+    # Each source is specified in the inventory using the 'sources' key.
+    class Source
+
+      # @return [String] The URL for this source
+      attr_accessor :base_url
+
+      # @param [String] base_url The URL for this source
+      def initialize(base_url)
+        @base_url = base_url
+      end
+
+      # Search through the cookbooks available at this source, and return
+      # the relevant version if it is available.
+      # @return [Minimart::Mirror::SourceCookbook]
+      def find_cookbook(cookbook_name, version)
+        cookbooks.find do |cookbook|
+          cookbook.name == cookbook_name && cookbook.version == version
+        end
+      end
+
+      # Query this source for it's available cookbooks using the '/universe' endpoint.
+      # @return [Array<Minimart::Mirror::SourceCookbook]
+      def cookbooks
+        @cookbooks ||= fetch_universe_data.each_with_object([]) do |cookbook_info, memo|
+          name, versions = cookbook_info
+          memo.concat versions.map { |version, attrs| build_cookbook(name, version, attrs) }
+        end
+      end
+
+      def to_s
+        base_url
+      end
+
+      private
+
+      def build_cookbook(name, version, attrs)
+        attrs = attrs.merge(name: name, version: version)
+        SourceCookbook.new(attrs)
+      end
+
+      def fetch_universe_data
+        Configuration.output.puts "Fetching the universe for #{base_url} ..."
+
+        Utils::Http.get_json(base_url, 'universe')
+
+      rescue RestClient::ResourceNotFound
+        raise Error::UniverseNotFoundError.new "no universe found for #{base_url}"
+      end
+    end
+  end
+end

data/lib/minimart/mirror/source_cookbook.rb

@@ -0,0 +1,77 @@
+require 'minimart/download/cookbook'
+
+module Minimart
+  module Mirror
+
+    # A wrapper around a cookbook as found in the universe.json file from an
+    # external source (Chef Supermarket, etc...).
+    class SourceCookbook
+
+      # @return [String] the name of the cookbook
+      attr_accessor :name
+
+      # @return [String] the version of the cookbook
+      attr_accessor :version
+
+      # @return [Hash<String,String>] any dependencies the cookbook has
+      attr_accessor :dependencies
+
+      # @return [String] the path to the cookbook
+      attr_accessor :location_path
+
+      # @return [String] the type of location the cookbook is stored in (supermarket, etc.)
+      attr_accessor :location_type
+
+      # @return [String] URL to download the cookbook
+      attr_accessor :download_url
+
+      # @param [Hash] opts
+      # @option opts [String] name The name of the cookbook
+      # @option opts [String] version The version of the cookbook
+      # @option opts [String] location_path The path to the cookbook
+      # @option opts [String] download_url URL to download the cookbook
+      # @option opts [Hash] dependencies A hash containing any of the cookbook's dependencies.
+      # @option opts [String] location_type The type of location the cookbook is stored in (supermarket, etc.)
+      def initialize(opts)
+        @name          = fetch_from_options(opts, 'name')
+        @version       = fetch_from_options(opts, 'version')
+        @location_path = fetch_from_options(opts, 'location_path')
+        @download_url  = fetch_from_options(opts, 'download_url')
+        @dependencies  = fetch_from_options(opts, 'dependencies') || {}
+        @location_type = fetch_from_options(opts, 'location_type')
+      end
+
+      # Download this remote cookbook
+      # @yield [Dir] The path to the downloaded cookbook. This directory will be removed when the block exits.
+      def fetch(&block)
+        Download::Cookbook.new(self).fetch(&block)
+      end
+
+      # Convert this remote cookbook to a Hash
+      # @return [Hash]
+      def to_hash
+        {
+          source_type: location_type,
+          location:    location_path
+        }
+      end
+
+      # Get the location_path as a URI
+      # @return [URI]
+      def location_path_uri
+        URI.parse(location_path)
+      end
+
+      def web_friendly_version
+        version.gsub('.', '_')
+      end
+
+      private
+
+      def fetch_from_options(opts, key)
+        opts[key] || opts[key.to_sym]
+      end
+
+    end
+  end
+end

data/lib/minimart/mirror/sources.rb

@@ -0,0 +1,37 @@
+module Minimart
+  module Mirror
+    # A collection of Minimart::Mirror::Source
+    class Sources < Array
+
+      # @param [Array<String>] source_urls An array of source URL's specified in the inventory
+      def initialize(source_urls = [])
+        source_urls.each { |source_url| add_source(source_url) }
+      end
+
+      # Iterate over each cookbook defined in each source
+      # @yield [Minimart::Mirror::SourceCookbook]
+      def each_cookbook(&block)
+        each { |source| source.cookbooks.each(&block) }
+      end
+
+      # Find the first cookbook from the avaiable sources with a matching name, and
+      # version
+      # @param [String] name The name of the cookbook to search for
+      # @param [String] version The version of the cookbook to search for
+      def find_cookbook(name, version)
+        each do |source|
+          cookbook = source.find_cookbook(name, version)
+          return cookbook if cookbook
+        end
+
+        raise Error::CookbookNotFound, "The cookbook #{name} with the version #{version} could not be found"
+      end
+
+      private
+
+      def add_source(source_url)
+        self << Source.new(source_url)
+      end
+    end
+  end
+end

data/lib/minimart/output.rb

@@ -0,0 +1,34 @@
+module Minimart
+  # Wrapper for IO to provide colored output.
+  class Output
+
+    attr_reader :io
+
+    def initialize(io)
+      @io = io
+    end
+
+    def puts(*args)
+      io.puts(args)
+    end
+
+    def puts_red(str)
+      puts_color(31, str)
+    end
+
+    def puts_green(str)
+      puts_color(32, str)
+    end
+
+    def puts_yellow(str)
+      puts_color(33, str)
+    end
+
+    private
+
+    def puts_color(color_code, str)
+      self.puts "\e[#{color_code}m#{str}\e[0m"
+    end
+
+  end
+end

data/lib/minimart/utils/archive.rb

@@ -0,0 +1,39 @@
+require 'archive/tar/minitar'
+require 'zlib'
+require 'minimart/mirror/download_metadata'
+
+module Minimart
+  module Utils
+
+    # Archive manages tarring, and gzipping files
+    module Archive
+
+      # Extract a tar.gz archive
+      # @param [String] archive_file The path to the archive file
+      # @param [String] destination The directory to unpack the archive to
+      def self.extract_archive(archive_file, destination)
+        tar = Zlib::GzipReader.new(File.open(archive_file, 'rb'))
+        ::Archive::Tar::Minitar.unpack(tar, destination)
+      end
+
+      # Build a tar.tz archive from a directory
+      # @param [Minimart::Cookbook] cookbook The cookbook to archive
+      # @param [String] destination The path to store the tar.gz archive
+      def self.pack_archive(cookbook, destination)
+        Dir.mktmpdir do |tmp|
+          Dir.chdir(tmp) do
+            archive_dir = File.join(tmp, cookbook.name)
+            FileUtils.mkdir_p(archive_dir)
+            FileUtils.cp_r(File.join(cookbook.path, '.'), archive_dir)
+            meta_file = File.join(archive_dir, Minimart::Mirror::DownloadMetadata::FILE_NAME)
+            FileUtils.remove_entry(meta_file) if File.exists?(meta_file)
+
+            tgz = Zlib::GzipWriter.new(File.open(destination, 'wb'))
+            ::Archive::Tar::Minitar.pack(cookbook.name, tgz)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/minimart/utils/file_helper.rb

@@ -0,0 +1,34 @@
+module Minimart
+  module Utils
+    # FileHelper contains helper methods for dealing with the file system.
+    module FileHelper
+
+      # Find the first cookbook in the given path
+      # @param [String] path The directory to search for cookbooks in
+      # @return [String] The path to the cookbook
+      def self.cookbook_path_in_directory(path)
+        cookbook_in_path?(path) ? path : find_cookbooks_in_directory(path).first
+      end
+
+      # List all of the cookbooks in a given directory
+      # @param [String] path The directory to find cookbooks in
+      # @return [Array<String>] An array of paths to any cookbooks found in the supplied path.
+      def self.find_cookbooks_in_directory(path)
+        Dir.glob(File.join(path, '/*/')).select { |d| cookbook_in_path?(d) }
+      end
+
+      # Determine whether or not a given directory contains a cookbook.
+      # @param [String] path The directory to check
+      # @return [Boolean]
+      def self.cookbook_in_path?(path)
+        file_exists?(File.join(path, 'metadata.json')) ||
+          file_exists?(File.join(path, 'metadata.rb'))
+      end
+
+      def self.file_exists?(path)
+        File.exists?(path)
+      end
+
+    end
+  end
+end

data/lib/minimart/utils/http.rb

@@ -0,0 +1,60 @@
+require 'rest_client'
+require 'uri'
+
+module Minimart
+  module Utils
+    # A collection of methods to help issue HTTP requests
+    module Http
+
+      # Issue a GET request to a URL, and return parsed JSON.
+      # @param [String] url The base URL to hit
+      # @param [String] path The path to the RESTful resource to fetch
+      # @return [Hash] The parsed JSON response
+      def self.get_json(url, path=nil)
+        JSON.parse(get(url, path, accept: 'application/json'))
+      end
+
+      # Issue a GET request to a URL
+      # @param [String] base_url The base URL to hit
+      # @param [String] path The path to the RESTful resource to fetch
+      def self.get(base_url, path=nil, headers={})
+        headers = headers.merge(verify_ssl: Minimart::Configuration.verify_ssl)
+
+        resource = RestClient::Resource.new(base_url.to_s)
+        path ? resource[path].get(headers) : resource.get(headers)
+      end
+
+      # GET a binary file
+      # @param [String] base_name A base name to give the returned file
+      # @param [String] url The base URL to hit
+      # @param [String] path The path to the RESTful resource to fetch
+      # @return [Tempfile]
+      def self.get_binary(base_name, url, path=nil)
+        result = Tempfile.new(base_name)
+        result.binmode
+        result.write(get(url, path))
+        result.close(false)
+        result
+      end
+
+      # Build a URL from a base URL, and a path
+      # @param [String] base_url The base URL to hit
+      # @param [String] path
+      def self.build_url(base_url, path=nil)
+        result = (base_url =~ /\A[a-z].*:\/\//i) ? base_url : "http://#{base_url}"
+        result = URI.parse(result).to_s
+        result = concat_url_fragment(result, path)
+        return result
+      end
+
+      def self.concat_url_fragment(frag_one, frag_two)
+        return frag_one unless frag_two
+        result = frag_one
+        result << '/' unless result[-1] == '/'
+        result << ((frag_two[0] == '/') ? frag_two[1..-1] : frag_two)
+        result
+      end
+
+    end
+  end
+end

data/lib/minimart/version.rb

@@ -0,0 +1,3 @@
+module Minimart
+  VERSION = "0.0.1"
+end

data/lib/minimart/web.rb

@@ -0,0 +1,10 @@
+module Minimart
+  # The Web namespace is used for building the cookbook index, and generating
+  # any HTML.
+  module Web
+    require 'minimart/web/cookbooks'
+    require 'minimart/web/html_generator'
+    require 'minimart/web/template_helper'
+    require 'minimart/web/universe_generator'
+  end
+end

data/lib/minimart/web/cookbook_show_page_generator.rb

@@ -0,0 +1,78 @@
+module Minimart
+  module Web
+    # Generate "show" pages for a set of cookbooks
+    class CookbookShowPageGenerator
+      include TemplateHelper
+
+      # @return [String] the directory to put any generated HTML in
+      attr_reader :web_directory
+
+      # @return [Minimart::Web::Cookbooks] the cookbooks to generate show pages for
+      attr_reader :cookbooks
+
+      # @param [Hash] opts
+      # @option opts [String] :web_directory The directory to put any generated HTML in
+      # @option opts [String] :cookbooks The cookbooks to generate show pages for
+      def initialize(opts = {})
+        @web_directory = opts[:web_directory]
+        @cookbooks     = opts[:cookbooks]
+      end
+
+      # Generate the HTML!
+      def generate
+        clean_web_cookbooks_directory
+        make_web_cookbooks_directory
+        create_html_files
+      end
+
+      private
+
+      def clean_web_cookbooks_directory
+        return unless Dir.exists?(cookbooks_directory)
+        FileUtils.remove_entry(cookbooks_directory)
+      end
+
+      def make_web_cookbooks_directory
+        FileUtils.mkdir_p(cookbooks_directory)
+      end
+
+      def create_html_files
+        cookbooks.each do |cookbook_name, versions|
+          versions.each do |cookbook|
+            write_to_file(file(cookbook), template_content(cookbook, versions))
+          end
+        end
+      end
+
+      def file(cookbook)
+        FileUtils.mkdir_p(File.join(web_directory, cookbook_dir(cookbook)))
+        File.join(web_directory, cookbook_file(cookbook))
+      end
+
+      def template_content(cookbook, versions)
+        render_in_base_layout do
+          render_template('cookbook_show.erb', self, {cookbook: cookbook, other_versions: versions})
+        end
+      end
+
+      def write_to_file(file_path, content)
+        File.open(file_path, 'w+') { |f| f.write(content) }
+      end
+
+      def cookbooks_directory
+        File.join(web_directory, 'cookbooks')
+      end
+
+      def cookbook_for_requirement(name, version_requirement)
+        (cookbooks[name] || []).find do |c|
+          c.satisfies_requirement?(version_requirement)
+        end
+      end
+
+      def level
+        2
+      end
+
+    end
+  end
+end

data/lib/minimart/web/cookbooks.rb

@@ -0,0 +1,83 @@
+require 'forwardable'
+
+require 'minimart/cookbook'
+require 'minimart/utils/file_helper'
+
+module Minimart
+  module Web
+    # Given a path to the inventory directory, this class will generate the necessary
+    # JSON output to power the main dashboard, and return cookbooks in a format
+    # that can be used to build the various web pages.
+    class Cookbooks
+      extend Forwardable
+
+      include Enumerable
+
+      FILE_NAME = 'data.json'
+
+      # @return [String] The path to the cookbook inventory
+      attr_reader :inventory_directory
+
+      # @param [Hash] opts
+      # @option opts [String] :inventory_directory The path to the cookbook inventory
+      def initialize(opts)
+        @inventory_directory = opts[:inventory_directory]
+        @data_structure = {}
+
+        generate
+      end
+
+      # Get a JSON representation of the most recent version of each cookbook
+      # found in the inventory_directory.
+      # @return [Hash]
+      def to_json
+        map do |cookbook_name, cookbook_versions|
+          cookbook_versions.first.to_hash.merge(available_versions: cookbook_versions.size)
+        end.to_json
+      end
+
+      def_delegators :data_structure, :each, :keys, :values, :[]
+
+      # Get a non-nested version of the cookbooks structure
+      def individual_cookbooks
+        values.flatten
+      end
+
+      # Add a cookbook to the data structure.
+      # @param [Minimart::Cookbook] cookbook The cookbook to add
+      def add(cookbook)
+        data_structure[cookbook.name] ||= []
+        data_structure[cookbook.name] << cookbook
+      end
+
+      private
+
+      attr_reader :data_structure
+
+      def generate
+        build_data_structure
+        sort_data
+      end
+
+      def build_data_structure
+        cookbooks.each { |cookbook| add(cookbook) }
+      end
+
+      # Sort cookbooks in version desc order
+      def sort_data
+        data_structure.values.map! do |versions|
+          versions.sort!.reverse!
+        end
+      end
+
+      def cookbooks
+        inventory_cookbook_paths.map { |path| Minimart::Cookbook.from_path(path) }
+      end
+
+      def inventory_cookbook_paths
+        Utils::FileHelper.find_cookbooks_in_directory(inventory_directory)
+      end
+
+    end
+  end
+end