librarian 0.0.1

data/lib/librarian/chef/manifest.rb

@@ -0,0 +1,43 @@
+require 'json'
+require 'yaml'
+
+require 'librarian/manifest'
+
+module Librarian
+  module Chef
+    class Manifest < Manifest
+
+      module Helpers
+
+        MANIFESTS = %w(metadata.json metadata.yml metadata.yaml metadata.rb)
+
+        def manifest_path(path)
+          MANIFESTS.map{|s| path.join(s)}.find{|s| s.exist?}
+        end
+
+        def read_manifest(name, manifest_path)
+          case manifest_path.extname
+          when ".json" then JSON.parse(manifest_path.read)
+          when ".yml", ".yaml" then YAML.load(manifest_path.read)
+          when ".rb" then compile_manifest(name, manifest_path.dirname)
+          end
+        end
+
+        def compile_manifest(name, path)
+          # Inefficient, if there are many cookbooks with uncompiled metadata.
+          require 'chef/json_compat'
+          require 'chef/cookbook/metadata'
+          md = ::Chef::Cookbook::Metadata.new
+          md.name(name)
+          md.from_file(path.join('metadata.rb').to_s)
+          JSON.parse(::Chef::JSONCompat.to_json_pretty(md))
+        end
+
+      end
+
+      include Helpers
+      extend Helpers
+
+    end
+  end
+end

data/lib/librarian/chef/particularity.rb

@@ -0,0 +1,9 @@
+module Librarian
+  module Chef
+    module Particularity
+      def root_module
+        Chef
+      end
+    end
+  end
+end

data/lib/librarian/chef/source.rb

@@ -0,0 +1,3 @@
+require 'librarian/chef/source/path'
+require 'librarian/chef/source/git'
+require 'librarian/chef/source/site'

data/lib/librarian/chef/source/git.rb

@@ -0,0 +1,14 @@
+require 'librarian/source/git'
+require 'librarian/chef/source/local'
+require 'librarian/chef/particularity'
+
+module Librarian
+  module Chef
+    module Source
+      class Git < Librarian::Source::Git
+        include Particularity
+        include Local
+      end
+    end
+  end
+end

data/lib/librarian/chef/source/local.rb

@@ -0,0 +1,80 @@
+require 'fileutils'
+require 'pathname'
+
+require 'librarian/chef/manifest'
+
+module Librarian
+  module Chef
+    module Source
+      module Local
+
+        class Manifest < Manifest
+
+          class << self
+
+            def create(source, dependency, path)
+              new(source, dependency.name, path)
+            end
+
+            def manifest?(dependency, path)
+              path = Pathname.new(path)
+              manifest_path = manifest_path(path)
+              manifest_path && check_manifest(dependency, manifest_path)
+            end
+
+            def check_manifest(dependency, manifest_path)
+              manifest = read_manifest(dependency.name, manifest_path)
+              manifest["name"] == dependency.name
+            end
+
+          end
+
+          attr_reader :path
+
+          def initialize(source, name, path)
+            super(source, name)
+            @path = Pathname.new(path)
+            @found_path = nil
+          end
+
+          def found_path
+            @found_path ||= source.manifest_search_paths(self).find{|p| self.class.manifest?(self, p)}
+          end
+
+          def manifest
+            @manifest ||= fetch_manifest!
+          end
+
+          def fetch_manifest!
+            read_manifest(name, manifest_path(found_path))
+          end
+
+          def fetch_version!
+            manifest['version']
+          end
+
+          def fetch_dependencies!
+            manifest['dependencies']
+          end
+
+          def install!
+            debug { "Installing #{name}-#{version}" }
+            install_path = root_module.install_path.join(name)
+            if install_path.exist?
+              debug { "Deleting #{relative_path_to(install_path)}" }
+              install_path.rmtree
+            end
+            debug { "Copying #{relative_path_to(found_path)} to #{relative_path_to(install_path)}" }
+            FileUtils.cp_r(found_path, install_path)
+          end
+
+        end
+
+        def manifest_class
+          Manifest
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/chef/source/path.rb

@@ -0,0 +1,14 @@
+require 'librarian/source/path'
+require 'librarian/chef/source/local'
+require 'librarian/chef/particularity'
+
+module Librarian
+  module Chef
+    module Source
+      class Path < Librarian::Source::Path
+        include Particularity
+        include Local
+      end
+    end
+  end
+end

data/lib/librarian/chef/source/site.rb

@@ -0,0 +1,271 @@
+require 'fileutils'
+require 'pathname'
+require 'uri'
+require 'net/http'
+require 'json'
+require 'digest'
+
+require 'librarian/helpers/debug'
+
+require 'librarian/manifest'
+require 'librarian/chef/manifest'
+require 'librarian/chef/particularity'
+
+module Librarian
+  module Chef
+    module Source
+      class Site
+
+        class Manifest < Manifest
+
+          attr_reader :version_uri
+          attr_reader :install_path
+
+          def initialize(source, name, version_uri = nil)
+            super(source, name)
+            @version_uri = version_uri
+
+            @cache_path = nil
+            @metadata_cache_path = nil
+            @package_cache_path = nil
+            @install_path = root_module.install_path.join(name)
+
+            @version_metadata = nil
+            @version_manifest = nil
+          end
+
+          def fetch_version!
+            version_metadata['version']
+          end
+
+          def fetch_dependencies!
+            version_manifest['dependencies'].map{|k, v| Dependency.new(k, v, nil)}
+          end
+
+          def version_uri
+            @version_uri ||= begin
+              source.cache!([self])
+              source.manifests(self).find{|m| m.version == version}.version_uri
+            end
+          end
+
+          def version_uri=(version_uri)
+            @version_uri = version_uri
+          end
+
+          def cache_path
+            @cache_path ||= source.version_cache_path(self, version_uri)
+          end
+          def metadata_cache_path
+            @metadata_cache_path ||= cache_path.join('version.json')
+          end
+          def package_cache_path
+            @package_cache_path ||= cache_path.join('package')
+          end
+
+          def version_metadata
+            @version_metadata ||= fetch_version_metadata!
+          end
+
+          def fetch_version_metadata!
+            source.cache_version_metadata!(self, version_uri)
+            JSON.parse(metadata_cache_path.read)
+          end
+
+          def version_manifest
+            @version_manifest ||= fetch_version_manifest!
+          end
+
+          def fetch_version_manifest!
+            source.cache_version_package!(self, version_uri, version_metadata['file'])
+            manifest_path = manifest_path(package_cache_path)
+            read_manifest(name, manifest_path)
+          end
+
+          def install!
+            debug { "Installing #{self}" }
+            version_manifest # make sure it's cached
+            if install_path.exist?
+              debug { "Deleting #{relative_path_to(install_path)}" }
+              install_path.rmtree
+            end
+            package_cache_path = source.version_package_cache_path(self, version_uri)
+            debug { "Copying #{relative_path_to(package_cache_path)} to #{relative_path_to(install_path)}" }
+            FileUtils.cp_r(package_cache_path, install_path)
+          end
+
+        end
+
+        include Helpers::Debug
+        include Particularity
+
+        class << self
+          LOCK_NAME = 'SITE'
+          def lock_name
+            LOCK_NAME
+          end
+          def from_lock_options(options)
+            new(options[:remote], options.reject{|k, v| k == :remote})
+          end
+        end
+
+        attr_reader :uri
+
+        def initialize(uri, options = {})
+          @uri = uri
+          @cache_path = nil
+        end
+
+        def to_s
+          uri
+        end
+
+        def ==(other)
+          other &&
+          self.class  == other.class &&
+          self.uri    == other.uri
+        end
+
+        def to_spec_args
+          [uri, {}]
+        end
+
+        def to_lock_options
+          {:remote => uri}
+        end
+
+        def cache!(dependencies)
+          cache_path.mkpath
+          dependencies.each do |dependency|
+            cache_metadata!(dependency)
+          end
+        end
+
+        # NOTE:
+        #   Assumes the Opscode Site API responds with versions in reverse sorted order
+        def manifests(dependency)
+          metadata = JSON.parse(metadata_cache_path(dependency).read)
+          metadata['versions'].map{|version_uri| Manifest.new(self, dependency.name, version_uri)}
+        end
+
+        def manifest(name, version, dependencies)
+          manifest = Manifest.new(self, name)
+          manifest.version = version
+          manifest.dependencies = dependencies
+          manifest
+        end
+
+        def install_path(dependency)
+          root_module.install_path.join(dependency.name)
+        end
+
+        def cache_path
+          @cache_path ||= begin
+            dir = Digest::MD5.hexdigest(uri)
+            root_module.cache_path.join("source/chef/site/#{dir}")
+          end
+        end
+
+        def dependency_cache_path(dependency)
+          cache_path.join(dependency.name)
+        end
+
+        def metadata_cache_path(dependency)
+          dependency_cache_path(dependency).join("metadata.json")
+        end
+
+        def version_cache_path(dependency, version_uri)
+          dependency_cache_path(dependency).join(Digest::MD5.hexdigest(version_uri))
+        end
+
+        def version_metadata_cache_path(dependency, version_uri)
+          version_cache_path(dependency, version_uri).join("version.json")
+        end
+
+        def version_archive_cache_file(dependency, version_uri)
+          Pathname.new("archive.tgz")
+        end
+
+        def version_archive_cache_path(dependency, version_uri)
+          version_archive_cache_file = version_archive_cache_file(dependency, version_uri)
+          version_cache_path(dependency, version_uri).join(version_archive_cache_file)
+        end
+
+        def version_unpacked_cache_file(dependency, version_uri)
+          Pathname.new(dependency.name)
+        end
+
+        def version_unpacked_cache_path(dependency, version_uri)
+          version_unpacked_cache_file = version_unpacked_cache_file(dependency, version_uri)
+          version_cache_path(dependency, version_uri).join(version_unpacked_cache_file)
+        end
+
+        def version_package_cache_file(dependency, version_uri)
+          Pathname.new("package")
+        end
+
+        def version_package_cache_path(dependency, version_uri)
+          version_package_cache_file = version_package_cache_file(dependency, version_uri)
+          version_cache_path(dependency, version_uri).join(version_package_cache_file)
+        end
+
+        def dependency_uri(dependency)
+          "#{uri}/cookbooks/#{dependency.name}"
+        end
+
+        def cache_metadata!(dependency)
+          dependency_cache_path = cache_path.join(dependency.name)
+          dependency_cache_path.mkpath
+          metadata_cache_path = metadata_cache_path(dependency)
+          unless metadata_cache_path.exist?
+            dep_uri = URI.parse(dependency_uri(dependency))
+            debug { "Caching #{dep_uri}" }
+            http = Net::HTTP.new(dep_uri.host, dep_uri.port)
+            request = Net::HTTP::Get.new(dep_uri.path)
+            response = http.start{|http| http.request(request)}
+            unless Net::HTTPSuccess === response
+              raise Error, "Could not cache #{dependency} from #{dep_uri} because #{response.code} #{response.message}!"
+            end
+            metadata_blob = response.body
+            JSON.parse(metadata_blob) # check that it's JSON
+            metadata_cache_path(dependency).open('wb') do |f|
+              f.write(metadata_blob)
+            end
+          end
+        end
+
+        def cache_version_metadata!(dependency, version_uri)
+          version_cache_path = version_cache_path(dependency, version_uri)
+          unless version_cache_path.exist?
+            version_cache_path.mkpath
+            debug { "Caching #{version_uri}" }
+            version_metadata_blob = Net::HTTP.get(URI.parse(version_uri))
+            JSON.parse(version_metadata_blob) # check that it's JSON
+            version_metadata_cache_path(dependency, version_uri).open('wb') do |f|
+              f.write(version_metadata_blob)
+            end
+          end
+        end
+
+        def cache_version_package!(dependency, version_uri, file_uri)
+          version_archive_cache_path = version_archive_cache_path(dependency, version_uri)
+          unless version_archive_cache_path.exist?
+            version_archive_cache_path.open('wb') do |f|
+              f.write(Net::HTTP.get(URI.parse(file_uri)))
+            end
+          end
+          version_package_cache_path = version_package_cache_path(dependency, version_uri)
+          unless version_package_cache_path.exist?
+            dependency_cache_path = dependency_cache_path(dependency)
+            Dir.chdir(dependency_cache_path) do
+              `tar -xzf #{version_archive_cache_path}`
+            end
+            version_unpacked_temp_path = dependency_cache_path.join(dependency.name)
+            FileUtils.move(version_unpacked_temp_path, version_package_cache_path)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/cli.rb

@@ -0,0 +1,76 @@
+require 'thor'
+require 'thor/actions'
+require 'librarian'
+
+module Librarian
+  class Cli < Thor
+
+    include Thor::Actions
+    include Particularity
+    extend Particularity
+
+    class << self
+      def bin!
+        begin
+          start
+        rescue Librarian::Error => e
+          root_module.ui.error e.message
+          root_module.ui.debug e.backtrace.join("\n")
+          exit (e.respond_to?(:status_code) ? e.status_code : 1)
+        rescue Interrupt => e
+          root_module.ui.error "\nQuitting..."
+          exit 1
+        end
+      end
+    end
+
+    def initialize(*)
+      super
+      the_shell = (options["no-color"] ? Thor::Shell::Basic.new : shell)
+      root_module.ui = UI::Shell.new(the_shell)
+      root_module.ui.debug! if options["verbose"]
+      root_module.ui.debug_line_numbers! if options["verbose"] && options["line-numbers"]
+    end
+
+    desc "clean", "Cleans out the cache and install paths."
+    method_option "verbose"
+    method_option "line-numbers"
+    def clean
+      root_module.ensure!
+      root_module.clean!
+    end
+
+    desc "install", "Installs all of the dependencies you specify."
+    method_option "verbose"
+    method_option "line-numbers"
+    method_option "clean"
+    def install
+      root_module.ensure!
+      root_module.clean! if options["clean"]
+      root_module.install!
+    end
+
+    desc "resolve", "Resolves the dependencies you specify."
+    method_option "verbose"
+    method_option "line-numbers"
+    method_option "clean"
+    def resolve
+      root_module.ensure!
+      root_module.clean! if options["clean"]
+      root_module.resolve!
+    end
+
+    desc "update", "Updates the dependencies you specify."
+    method_option "verbose"
+    method_option "line-numbers"
+    def update(*names)
+      root_module.ensure!
+      if names.empty?
+        root_module.resolve!(:force => true)
+      else
+        root_module.update!(names)
+      end
+    end
+
+  end
+end