anthill-librarian-puppet 3.0.0

data/lib/librarian/puppet/action/resolve.rb

@@ -0,0 +1,21 @@
+require 'librarian/action/resolve'
+
+module Librarian
+  module Puppet
+    module Action
+      class Resolve < Librarian::Action::Resolve
+        include Librarian::Puppet::Util
+
+        def run
+          super
+          manifests = environment.lock.manifests.select{ |m| m.name }
+          dupes = manifests.group_by{ |m| module_name(m.name) }.select { |k, v| v.size > 1 }
+          dupes.each do |k,v|
+            warn("Dependency on module '#{k}' is fullfilled by multiple modules and only one will be used: #{v.map{|m|m.name}}")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/puppet/cli.rb

@@ -0,0 +1,110 @@
+require 'librarian/helpers'
+
+require 'librarian/cli'
+require 'librarian/puppet'
+require 'librarian/puppet/action'
+
+module Librarian
+  module Puppet
+    class Cli < Librarian::Cli
+      include Librarian::Puppet::Util
+
+      module Particularity
+        def root_module
+          Puppet
+        end
+      end
+
+      include Particularity
+      extend Particularity
+
+      source_root Pathname.new(__FILE__).dirname.join("templates")
+
+      def init
+        copy_file environment.specfile_name
+
+        if File.exists? ".gitignore"
+          gitignore = File.read('.gitignore').split("\n")
+        else
+          gitignore = []
+        end
+
+        gitignore << ".tmp/" unless gitignore.include? ".tmp/"
+        gitignore << "modules/" unless gitignore.include? "modules/"
+
+        File.open(".gitignore", 'w') do |f|
+          f.puts gitignore.join("\n")
+        end
+      end
+
+      desc "install", "Resolves and installs all of the dependencies you specify."
+      option "quiet", :type => :boolean, :default => false
+      option "verbose", :type => :boolean, :default => false
+      option "line-numbers", :type => :boolean, :default => false
+      option "clean", :type => :boolean, :default => false
+      option "strip-dot-git", :type => :boolean
+      option "path", :type => :string
+      option "destructive", :type => :boolean, :default => false
+      option "local", :type => :boolean, :default => false
+      option "use-v1-api", :type => :boolean, :default => true
+      option "use-short-cache-path", :type => :boolean, :default => false
+      def install
+
+        ensure!
+        clean! if options["clean"]
+        unless options["destructive"].nil?
+          environment.config_db.local['destructive'] = options['destructive'].to_s
+        end
+        if options.include?("strip-dot-git")
+          strip_dot_git_val = options["strip-dot-git"] ? "1" : nil
+          environment.config_db.local["install.strip-dot-git"] = strip_dot_git_val
+        end
+        if options.include?("path")
+          environment.config_db.local["path"] = options["path"]
+        end
+
+        environment.config_db.local['use-v1-api'] = options['use-v1-api'] ? '1' : nil
+        environment.config_db.local['mode'] = options['local'] ? 'local' : nil
+        environment.config_db.local['use-short-cache-path'] = options['use-short-cache-path'] ? '1' : nil
+
+        resolve!
+        debug { "Install: dependencies resolved"}
+        install!
+      end
+
+      # only used to replace / to - in the module names
+      def update(*names)
+        warn("Usage of module/name is deprecated, use module-name") if names.any? {|n| n.include?("/")}
+        super(*names.map{|n| normalize_name(n)})
+      end
+
+      desc "package", "Cache the puppet modules in vendor/puppet/cache."
+      option "quiet", :type => :boolean, :default => false
+      option "verbose", :type => :boolean, :default => false
+      option "line-numbers", :type => :boolean, :default => false
+      option "clean", :type => :boolean, :default => false
+      option "strip-dot-git", :type => :boolean
+      option "path", :type => :string
+      option "destructive", :type => :boolean, :default => false
+      def package
+        environment.vendor!
+        install
+      end
+
+      def version
+        say "librarian-puppet v#{Librarian::Puppet::VERSION}"
+      end
+
+      private
+
+      # override the actions to use our own
+
+      def install!(options = { })
+        Action::Install.new(environment, options).run
+      end
+      def resolve!(options = { })
+        Action::Resolve.new(environment, options).run
+      end
+    end
+  end
+end

data/lib/librarian/puppet/dependency.rb

@@ -0,0 +1,18 @@
+module Librarian
+  module Puppet
+
+    class Dependency < Librarian::Dependency
+
+      include Librarian::Puppet::Util
+
+      def initialize(name, requirement, source)
+        # Issue #235 fail if forge source is not defined
+        raise Error, "forge entry is not defined in Puppetfile" if source.instance_of?(Array) && source.empty?
+
+        super(normalize_name(name), requirement, source)
+      end
+
+    end
+
+  end
+end

data/lib/librarian/puppet/dsl.rb

@@ -0,0 +1,92 @@
+require 'librarian/dsl'
+require 'librarian/dsl/target'
+require 'librarian/puppet/source'
+require 'librarian/puppet/dependency'
+
+module Librarian
+  module Puppet
+    class Dsl < Librarian::Dsl
+
+      FORGE_URL = "https://forgeapi.puppetlabs.com"
+
+      dependency :mod
+
+      source :forge => Source::Forge
+      source :git => Source::Git
+      source :path => Source::Path
+      source :github_tarball => Source::GitHubTarball
+
+      def default_specfile
+        Proc.new do
+          forge FORGE_URL
+          metadata
+        end
+      end
+
+      def self.dependency_type
+        Librarian::Puppet::Dependency
+      end
+
+      def post_process_target(target)
+        # save the default forge defined
+        default_forge = target.sources.select {|s| s.is_a? Librarian::Puppet::Source::Forge}.first
+        Librarian::Puppet::Source::Forge.default = default_forge || Librarian::Puppet::Source::Forge.from_lock_options(environment, :remote => FORGE_URL)
+      end
+
+      def receiver(target)
+        Receiver.new(target)
+      end
+
+      class Receiver < Librarian::Dsl::Receiver
+        attr_reader :specfile, :working_path
+
+        # save the specfile and call librarian
+        def run(specfile = nil)
+          @working_path = specfile.kind_of?(Pathname) ? specfile.parent : Pathname.new(Dir.pwd)
+          @specfile = specfile
+          super
+        end
+
+        # implement the 'modulefile' syntax for Puppetfile
+        def modulefile
+          f = modulefile_path
+          raise Error, "Modulefile file does not exist: #{f}" unless File.exists?(f)
+          File.read(f).lines.each do |line|
+            regexp = /\s*dependency\s+('|")([^'"]+)\1\s*(?:,\s*('|")([^'"]+)\3)?/
+            regexp =~ line && mod($2, $4)
+          end
+        end
+
+        # implement the 'metadata' syntax for Puppetfile
+        def metadata
+          f = working_path.join('metadata.json')
+          unless File.exists?(f)
+            msg = "Metadata file does not exist: #{f}"
+            # try modulefile, in case we don't have a Puppetfile and we are using the default template
+            if File.exists?(modulefile_path)
+              modulefile
+              return
+            else
+              raise Error, msg
+            end
+          end
+          begin
+            json = JSON.parse(File.read(f))
+          rescue JSON::ParserError => e
+            raise Error, "Unable to parse json file #{f}: #{e}"
+          end
+          dependencyList = json['dependencies']
+          dependencyList.each do |d|
+            mod(d['name'], d['version_requirement'])
+          end
+        end
+
+        private
+
+        def modulefile_path
+          working_path.join('Modulefile')
+        end
+      end
+    end
+  end
+end

data/lib/librarian/puppet/environment.rb

@@ -0,0 +1,66 @@
+require "librarian/environment"
+require "librarian/puppet/dsl"
+require "librarian/puppet/source"
+require "librarian/puppet/lockfile"
+
+module Librarian
+  module Puppet
+    class Environment < Librarian::Environment
+
+      def adapter_name
+        "puppet"
+      end
+
+      def lockfile
+        Lockfile.new(self, lockfile_path)
+      end
+
+      def ephemeral_lockfile
+        Lockfile.new(self, nil)
+      end
+
+      def tmp_path
+        part = config_db["tmp"] || ".tmp"
+        project_path.join(part)
+      end
+
+      def install_path
+        part = config_db["path"] || "modules"
+        project_path.join(part)
+      end
+
+      def vendor_path
+        project_path.join('vendor/puppet')
+      end
+
+      def vendor_cache
+        vendor_path.join('cache')
+      end
+
+      def vendor_source
+        vendor_path.join('source')
+      end
+
+      def vendor!
+        vendor_cache.mkpath  unless vendor_cache.exist?
+        vendor_source.mkpath unless vendor_source.exist?
+      end
+
+      def vendor?
+        vendor_path.exist?
+      end
+
+      def local?
+        config_db['mode'] == 'local'
+      end
+
+      def use_v1_api
+        config_db['use-v1-api']
+      end
+
+      def use_short_cache_path
+        config_db['use-short-cache-path']
+      end
+    end
+  end
+end

data/lib/librarian/puppet/extension.rb

@@ -0,0 +1,9 @@
+require 'librarian/puppet/environment'
+require 'librarian/action/base'
+
+module Librarian
+  module Puppet
+    extend self
+    extend Librarian
+  end
+end

data/lib/librarian/puppet/lockfile.rb

@@ -0,0 +1,39 @@
+# Extend Lockfile to normalize module names from acme/mod to acme-mod
+module Librarian
+  module Puppet
+    class Lockfile < Librarian::Lockfile
+
+      # Extend the parser to normalize module names in old .lock files, converting / to -
+      class Parser < Librarian::Lockfile::Parser
+
+        include Librarian::Puppet::Util
+
+        def extract_and_parse_sources(lines)
+          sources = super
+          sources.each do |source|
+            source[:manifests] = Hash[source[:manifests].map do |name,manifest|
+              [normalize_name(name), manifest]
+            end]
+          end
+          sources
+        end
+
+        def extract_and_parse_dependencies(lines, manifests_index)
+          # when looking up in manifests_index normalize the name beforehand
+          class << manifests_index
+            include Librarian::Puppet::Util
+            alias_method :old_lookup, :[]
+            define_method(:[]) { |k| self.old_lookup(normalize_name(k)) }
+          end
+          super(lines, manifests_index)
+        end
+
+      end
+
+      def load(string)
+        Parser.new(environment).parse(string)
+      end
+
+    end
+  end
+end

data/lib/librarian/puppet/source.rb

@@ -0,0 +1,4 @@
+require 'librarian/puppet/source/path'
+require 'librarian/puppet/source/git'
+require 'librarian/puppet/source/forge'
+require 'librarian/puppet/source/githubtarball'

data/lib/librarian/puppet/source/forge.rb

@@ -0,0 +1,181 @@
+require 'uri'
+require 'librarian/puppet/util'
+require 'librarian/puppet/source/forge/repo_v1'
+require 'librarian/puppet/source/forge/repo_v3'
+
+module Librarian
+  module Puppet
+    module Source
+      class Forge
+        include Librarian::Puppet::Util
+
+        class << self
+          LOCK_NAME = 'FORGE'
+
+          def default=(source)
+            @@default = source
+          end
+
+          def default
+            @@default
+          end
+
+          def lock_name
+            LOCK_NAME
+          end
+
+          def from_lock_options(environment, options)
+            new(environment, options[:remote], options.reject { |k, v| k == :remote })
+          end
+
+          def from_spec_args(environment, uri, options)
+            recognised_options = []
+            unrecognised_options = options.keys - recognised_options
+            unless unrecognised_options.empty?
+              raise Error, "unrecognised options: #{unrecognised_options.join(", ")}"
+            end
+
+            new(environment, uri, options)
+          end
+
+          def client_api_version()
+            version = 1
+            pe_version = Librarian::Puppet.puppet_version.match(/\(Puppet Enterprise (.+)\)/)
+
+            # Puppet 3.6.0+ uses api v3
+            if Librarian::Puppet::puppet_gem_version >= Gem::Version.create('3.6.0.a')
+              version = 3
+            # Puppet enterprise 3.2.0+ uses api v3
+            elsif pe_version and Gem::Version.create(pe_version[1].strip) >= Gem::Version.create('3.2.0')
+              version = 3
+            end
+            return version
+          end
+
+        end
+
+        attr_accessor :environment
+        private :environment=
+        attr_reader :uri
+
+        def initialize(environment, uri, options = {})
+          self.environment = environment
+
+          if uri =~ %r{^http(s)?://forge\.puppetlabs\.com}
+            uri = "https://forgeapi.puppetlabs.com"
+            warn { "Replacing Puppet Forge API URL to use v3 #{uri}. You should update your Puppetfile" }
+          end
+
+          @uri = URI::parse(uri)
+          @cache_path = nil
+        end
+
+        def to_s
+          clean_uri(uri).to_s
+        end
+
+        def ==(other)
+          other &&
+          self.class == other.class &&
+          self.uri == other.uri
+        end
+
+        alias :eql? :==
+
+        def hash
+          self.to_s.hash
+        end
+
+        def to_spec_args
+          [clean_uri(uri).to_s, {}]
+        end
+
+        def to_lock_options
+          {:remote => clean_uri(uri).to_s}
+        end
+
+        def pinned?
+          false
+        end
+
+        def unpin!
+        end
+
+        def install!(manifest)
+          manifest.source == self or raise ArgumentError
+
+          debug { "Installing #{manifest}" }
+
+          name = manifest.name
+          version = manifest.version
+          install_path = install_path(name)
+          repo = repo(name)
+
+          repo.install_version! version, install_path
+        end
+
+        def manifest(name, version, dependencies)
+          manifest = Manifest.new(self, name)
+          manifest.version = version
+          manifest.dependencies = dependencies
+          manifest
+        end
+
+        def cache_path
+          @cache_path ||= begin
+            if environment.use_short_cache_path
+              # To shorten the cache path to avoid #17
+              # take only the first 7 digits of the SHA1 checksum of the forge URI
+              # (short Git commit hash approach)
+              dir = Digest::SHA1.hexdigest("#{uri.host}#{uri.path}")[0..6]
+            else
+              dir = "#{uri.host}#{uri.path}".gsub(/[^0-9a-z\-_]/i, '_')
+            end
+            environment.cache_path.join("source/puppet/forge/#{dir}")
+          end
+        end
+
+        def install_path(name)
+          environment.install_path.join(module_name(name))
+        end
+
+        def fetch_version(name, version_uri)
+          versions = repo(name).versions
+          if versions.include? version_uri
+            version_uri
+          else
+            versions.first
+          end
+        end
+
+        def fetch_dependencies(name, version, version_uri)
+          repo(name).dependencies(version).map do |k, v|
+            v = Librarian::Dependency::Requirement.new(v).to_gem_requirement
+            Dependency.new(k, v, nil)
+          end
+        end
+
+        def manifests(name)
+          repo(name).manifests
+        end
+
+      private
+
+        def repo(name)
+          @repo ||= {}
+
+          unless @repo[name]
+            # If we are using the official Forge then use API v3, otherwise use the preferred api 
+            # as defined by the CLI option use_v1_api
+            if uri.hostname =~ /\.puppetlabs\.com$/ || !environment.use_v1_api
+              @repo[name] = RepoV3.new(self, name)
+            else
+              @repo[name] = RepoV1.new(self, name)
+            end
+          end
+          @repo[name]
+        end
+      end
+    end
+  end
+end