r10k 3.5.2

data/lib/r10k/git/shellgit/working_repository.rb

@@ -0,0 +1,111 @@
+require 'r10k/git'
+require 'r10k/git/alternates'
+require 'r10k/git/shellgit/base_repository'
+
+# Manage a non-bare Git repository
+class R10K::Git::ShellGit::WorkingRepository < R10K::Git::ShellGit::BaseRepository
+
+  # @attribute [r] path
+  #   @return [Pathname]
+  attr_reader :path
+
+  # @return [Pathname] The path to the Git directory inside of this repository
+  def git_dir
+    @path + '.git'
+  end
+
+  def initialize(basedir, dirname)
+    @path = Pathname.new(File.join(basedir, dirname))
+  end
+
+  # Clone this git repository
+  #
+  # @param remote [String] The Git remote to clone
+  # @param opts [Hash]
+  #
+  # @options opts [String] :ref The git ref to check out on clone
+  # @options opts [String] :reference A Git repository to use as an alternate object database
+  #
+  # @return [void]
+  def clone(remote, opts = {})
+    argv = ['clone', remote, @path.to_s]
+    if opts[:reference]
+      argv += ['--reference', opts[:reference]]
+    end
+
+    proxy = R10K::Git.get_proxy_for_remote(remote)
+
+    R10K::Git.with_proxy(proxy) do
+      git argv
+    end
+
+    if opts[:ref]
+      checkout(opts[:ref])
+    end
+  end
+
+  # Check out the given Git ref
+  #
+  # @param ref [String] The git reference to check out
+  # @param opts [Hash] Optional hash of additional options.
+  def checkout(ref, opts = {})
+    argv = ['checkout', ref]
+
+    # :force defaults to true
+    if !opts.has_key?(:force) || opts[:force]
+      argv << '--force'
+    end
+
+    git argv, :path => @path.to_s
+  end
+
+  def fetch(remote_name='origin')
+    remote = remotes[remote_name]
+    proxy = R10K::Git.get_proxy_for_remote(remote)
+
+    R10K::Git.with_proxy(proxy) do
+      git ['fetch', remote_name, '--prune'], :path => @path.to_s
+    end
+  end
+
+  def exist?
+    @path.exist?
+  end
+
+  # @return [String] The currently checked out ref
+  def head
+    resolve('HEAD')
+  end
+
+  def alternates
+    R10K::Git::Alternates.new(git_dir)
+  end
+
+  # @return [String] The origin remote URL
+  def origin
+    result = git(['config', '--get', 'remote.origin.url'], :path => @path.to_s, :raise_on_fail => false)
+    if result.success?
+      result.stdout
+    end
+  end
+
+  # does the working tree have local modifications to tracked files?
+  def dirty?
+    result = git(['diff-index', '--exit-code', '--name-only', 'HEAD'], :path => @path.to_s, :raise_on_fail => false)
+
+    if result.exit_code != 0
+      dirty_files = result.stdout.split('\n')
+
+      dirty_files.each do |file|
+        logger.debug(_("Found local modifications in %{file_path}" % {file_path: File.join(@path, file)}))
+
+        # Do this in a block so that the extra subprocess only gets invoked when needed.
+        logger.debug1 { git(['diff-index', '-p', 'HEAD', file], :path => @path.to_s, :raise_on_fail => false).stdout }
+      end
+
+      return true
+    else
+      return false
+    end
+  end
+end

data/lib/r10k/git/stateful_repository.rb

@@ -0,0 +1,95 @@
+require 'r10k/git'
+require 'r10k/git/errors'
+require 'forwardable'
+require 'r10k/logging'
+
+# Manage how Git repositories are created and set to specific refs
+class R10K::Git::StatefulRepository
+
+  include R10K::Logging
+
+  # @!attribute [r] repo
+  #   @api private
+  attr_reader :repo
+
+  extend Forwardable
+  def_delegators :@repo, :head, :tracked_paths
+
+  # Create a new shallow git working directory
+  #
+  # @param remote  [String] The git remote to use for the repo
+  # @param basedir [String] The path containing the Git repo
+  # @param dirname [String] The directory name of the Git repo
+  def initialize(remote, basedir, dirname)
+    @remote = remote
+    @cache = R10K::Git.cache.generate(@remote)
+    @repo = R10K::Git.thin_repository.new(basedir, dirname, @cache)
+  end
+
+  def resolve(ref)
+    @cache.sync if sync_cache?(ref)
+    @cache.resolve(ref)
+  end
+
+  def sync(ref, force=true)
+    @cache.sync if sync_cache?(ref)
+
+    sha = @cache.resolve(ref)
+
+    if sha.nil?
+      raise R10K::Git::UnresolvableRefError.new(_("Unable to sync repo to unresolvable ref '%{ref}'") % {ref: ref}, :git_dir => @repo.git_dir)
+    end
+
+    workdir_status = status(ref)
+
+    case workdir_status
+    when :absent
+      logger.debug(_("Cloning %{repo_path} and checking out %{ref}") % {repo_path: @repo.path, ref: ref })
+      @repo.clone(@remote, {:ref => sha})
+    when :mismatched
+      logger.debug(_("Replacing %{repo_path} and checking out %{ref}") % {repo_path: @repo.path, ref: ref })
+      @repo.path.rmtree
+      @repo.clone(@remote, {:ref => sha})
+    when :outdated
+      logger.debug(_("Updating %{repo_path} to %{ref}") % {repo_path: @repo.path, ref: ref })
+      @repo.checkout(sha, {:force => force})
+    when :dirty
+      if force
+        logger.warn(_("Overwriting local modifications to %{repo_path}") % {repo_path: @repo.path})
+        logger.debug(_("Updating %{repo_path} to %{ref}") % {repo_path: @repo.path, ref: ref })
+        @repo.checkout(sha, {:force => force})
+      else
+        logger.warn(_("Skipping %{repo_path} due to local modifications") % {repo_path: @repo.path})
+      end
+    else
+      logger.debug(_("%{repo_path} is already at Git ref %{ref}") % {repo_path: @repo.path, ref: ref })
+    end
+  end
+
+  def status(ref)
+    if !@repo.exist?
+      :absent
+    elsif !@repo.git_dir.exist?
+      :mismatched
+    elsif !@repo.git_dir.directory?
+      :mismatched
+    elsif !(@repo.origin == @remote)
+      :mismatched
+    elsif @repo.dirty?
+      :dirty
+    elsif !(@repo.head == @cache.resolve(ref))
+      :outdated
+    elsif @cache.ref_type(ref) == :branch && !@cache.synced?
+      :outdated
+    else
+      :insync
+    end
+  end
+
+  # @api private
+  def sync_cache?(ref)
+    return true if !@cache.exist?
+    return true if !([:commit, :tag].include? @cache.ref_type(ref))
+    return false
+  end
+end

data/lib/r10k/initializers.rb

@@ -0,0 +1,67 @@
+require 'r10k/logging'
+
+require 'r10k/git'
+require 'r10k/git/cache'
+
+require 'r10k/forge/module_release'
+
+module R10K
+  module Initializers
+    class BaseInitializer
+
+      include R10K::Logging
+
+      def initialize(settings)
+        @settings = settings
+      end
+
+      private
+
+      def with_setting(key)
+        if !@settings[key].nil?
+          yield @settings[key]
+        end
+      end
+    end
+
+    class GlobalInitializer < BaseInitializer
+      def call
+        with_setting(:purgedirs) do |_|
+          logger.warn(_("the purgedirs key in r10k.yaml is deprecated. it is currently ignored."))
+        end
+
+        with_setting(:deploy) { |value| DeployInitializer.new(value).call }
+
+        with_setting(:cachedir) { |value| R10K::Git::Cache.settings[:cache_root] = value }
+        with_setting(:cachedir) { |value| R10K::Forge::ModuleRelease.settings[:cache_root] = value }
+        with_setting(:pool_size) { |value| R10K::Puppetfile.settings[:pool_size] = value }
+
+        with_setting(:git) { |value| GitInitializer.new(value).call }
+        with_setting(:forge) { |value| ForgeInitializer.new(value).call }
+      end
+    end
+
+    class DeployInitializer < BaseInitializer
+      def call
+        with_setting(:puppet_path) { |value| R10K::Settings.puppet_path = value }
+      end
+    end
+
+    class GitInitializer < BaseInitializer
+      def call
+        with_setting(:provider) { |value| R10K::Git.provider = value }
+        with_setting(:username) { |value| R10K::Git.settings[:username] = value }
+        with_setting(:private_key) { |value| R10K::Git.settings[:private_key] = value }
+        with_setting(:proxy) { |value| R10K::Git.settings[:proxy] = value }
+        with_setting(:repositories) { |value| R10K::Git.settings[:repositories] = value }
+      end
+    end
+
+    class ForgeInitializer < BaseInitializer
+      def call
+        with_setting(:baseurl) { |value| PuppetForge.host = value }
+        with_setting(:proxy) { |value| PuppetForge::Connection.proxy = value }
+      end
+    end
+  end
+end

data/lib/r10k/instance_cache.rb

@@ -0,0 +1,32 @@
+module R10K
+
+  # This class implements a generic object memoization container. It caches
+  # new objects and returns cached objects based on the instantiation arguments.
+  class InstanceCache
+
+    # Initialize a new registry with a given class
+    #
+    # @param klass [Class] The class to memoize
+    # @param method [Symbol] The method name to use when creating objects.
+    #                        Defaults to :new.
+    def initialize(klass, method = :new)
+      @klass  = klass
+      @method = method
+      @instances = {}
+    end
+
+    # Create a new object, or return a memoized object.
+    #
+    # @param args [*Object] The arguments to pass to the initialize method
+    #
+    # @return [Object] A memoized instance of the registered class
+    def generate(*args)
+      @instances[args] ||= @klass.send(@method, *args)
+    end
+
+    # Clear all memoized objects
+    def clear!
+      @instances = {}
+    end
+  end
+end

data/lib/r10k/keyed_factory.rb

@@ -0,0 +1,39 @@
+module R10K
+
+  # This implements a factory by storing classes indexed with a given key and
+  # creates objects based on that key.
+  class KeyedFactory
+
+    # @!attribute [r] implementations
+    #   @return [Hash<Object, Class>] A hash of keys and the associated
+    #     implementations that this factory can generate.
+    attr_reader :implementations
+
+    def initialize
+      @implementations = {}
+    end
+
+    def register(key, klass)
+      if @implementations.has_key?(key)
+        raise DuplicateImplementationError, _("Class already registered for %{key}") % {key: key}
+      else
+        @implementations[key] = klass
+      end
+    end
+
+    def retrieve(key)
+      @implementations[key]
+    end
+
+    def generate(key, *args)
+      if (impl = @implementations[key])
+        impl.new(*args)
+      else
+        raise UnknownImplementationError, _("No class registered for %{key}") % {key: key}
+      end
+    end
+
+    class DuplicateImplementationError < StandardError; end
+    class UnknownImplementationError < StandardError; end
+  end
+end

data/lib/r10k/logging.rb

@@ -0,0 +1,109 @@
+require 'r10k'
+require 'forwardable'
+
+require 'log4r'
+require 'log4r/configurator'
+require 'r10k/logging/terminaloutputter'
+
+module R10K::Logging
+
+  LOG_LEVELS = %w{DEBUG2 DEBUG1 DEBUG INFO NOTICE WARN ERROR FATAL}
+
+  def logger_name
+    self.class.to_s
+  end
+
+  def logger
+    if @logger.nil?
+      name = logger_name
+      if Log4r::Logger[name]
+        @logger = Log4r::Logger[name]
+      else
+        @logger = Log4r::Logger.new(name)
+        @logger.add(R10K::Logging.outputter)
+      end
+    end
+    @logger
+  end
+
+  class << self
+
+    # Convert the input to a valid Log4r log level
+    #
+    # @param input [String, TrueClass] The level to parse. If TrueClass then
+    #   Log4r::INFO will be returned (indicating a generic raised verbosity),
+    #   if a string it will be parsed either as a numeric value or a textual
+    #   log level.
+    # @api private
+    # @return [Integer, NilClass] The numeric log level, or nil if the log
+    #   level is invalid.
+    def parse_level(input)
+      case input
+      when TrueClass
+        Log4r::INFO
+      when /\A\d+\Z/
+        Integer(input)
+      when String
+        const_name = input.upcase
+        if LOG_LEVELS.include?(const_name)
+          begin
+            Log4r.const_get(const_name.to_sym)
+          rescue NameError
+          end
+        end
+      end
+    end
+
+    def level=(val)
+      level = parse_level(val)
+      if level.nil?
+        raise ArgumentError, _("Invalid log level '%{val}'. Valid levels are %{log_levels}") % {val: val, log_levels: LOG_LEVELS.map(&:downcase).inspect}
+      end
+      outputter.level = level
+      @level = level
+
+      if level < Log4r::INFO
+        outputter.formatter = debug_formatter
+      else
+        outputter.formatter = default_formatter
+      end
+    end
+
+    extend Forwardable
+    def_delegators :@outputter, :use_color, :use_color=
+
+    # @!attribute [r] level
+    #   @return [Integer] The current log level. Lower numbers correspond
+    #     to more verbose log levels.
+    attr_reader :level
+
+    # @!attribute [r] formatter
+    #   @api private
+    #   @return [Log4r::Formatter]
+    attr_reader :formatter
+
+    # @!attribute [r] outputter
+    #   @api private
+    #   @return [Log4r::Outputter]
+    attr_reader :outputter
+
+    def default_formatter
+      Log4r::PatternFormatter.new(:pattern => '%l\t -> %m')
+    end
+
+    def debug_formatter
+      Log4r::PatternFormatter.new(:pattern => '[%d - %l] %m')
+    end
+
+    def default_outputter
+      R10K::Logging::TerminalOutputter.new('terminal', $stderr, :level => self.level, :formatter => formatter)
+    end
+  end
+
+  Log4r::Configurator.custom_levels(*LOG_LEVELS)
+  Log4r::Logger.global.level = Log4r::ALL
+
+  @level     = Log4r::WARN
+  @formatter = default_formatter
+  @outputter = default_outputter
+end