r10k 3.5.2

data/lib/r10k/git/alternates.rb

@@ -0,0 +1,63 @@
+require 'pathname'
+
+# Manage `$GIT_DIR/objects/info/alternates`
+#
+# @see man gitrepository-layout(5)
+class R10K::Git::Alternates
+
+  # @attribute [r] file
+  #   @return [Pathname] The alternates file
+  attr_reader :file
+
+  # @param git_dir [Pathname] The path to the git repository
+  def initialize(git_dir)
+    @file = git_dir + File.join('objects', 'info', 'alternates')
+    @entries = []
+  end
+
+  def add(path)
+    write(to_a << path)
+  end
+  alias << add
+
+  # Conditionally add path to the alternates file
+  #
+  # @param path [String] The file path to add to the file if not already present
+  # @return [true, false] If the entry was added.
+  def add?(path)
+    paths = read()
+
+    add_entry = !paths.include?(path)
+
+    if add_entry
+      paths << path
+      write(paths)
+    end
+
+    add_entry
+  end
+
+  def include?(path)
+    to_a.include?(path)
+  end
+
+  def write(entries)
+    if ! @file.parent.directory?
+      raise R10K::Git::GitError, _("Cannot write %{file}; parent directory does not exist") % {file: @file}
+    end
+    @file.open("w") do |fh|
+      entries.each do |entry|
+        fh.puts(entry)
+      end
+    end
+  end
+
+  def read
+    entries = []
+    if @file.file?
+      entries = @file.readlines.map(&:chomp)
+    end
+    entries
+  end
+  alias to_a read
+end

data/lib/r10k/git/cache.rb

@@ -0,0 +1,108 @@
+require 'r10k/git'
+
+require 'r10k/settings'
+require 'r10k/instance_cache'
+require 'forwardable'
+
+# Cache Git repository mirrors for object database reuse.
+#
+# This implements most of the behavior needed for Git repo caching, but needs
+# to have a specific Git bare repository provided. Subclasses should implement
+# the {bare_repository} method.
+#
+# @abstract
+# @see man git-clone(1)
+class R10K::Git::Cache
+
+  include R10K::Settings::Mixin
+
+  def_setting_attr :cache_root, File.expand_path(ENV['HOME'] ? '~/.r10k/git': '/root/.r10k/git')
+
+  @instance_cache = R10K::InstanceCache.new(self)
+
+  # @api private
+  def self.instance_cache
+    @instance_cache
+  end
+
+  # Generate a new instance with the given remote or return an existing object
+  # with the given remote. This should be used over R10K::Git::Cache.new.
+  #
+  # @api public
+  # @param remote [String] The git remote to cache
+  # @return [R10K::Git::Cache] The requested cache object.
+  def self.generate(remote)
+    instance_cache.generate(remote)
+  end
+
+  # @abstract
+  # @return [Object] The concrete bare repository implementation to use for
+  #   interacting with the cached Git repository.
+  def self.bare_repository
+    raise NotImplementedError
+  end
+
+  include R10K::Logging
+
+  extend Forwardable
+
+  def_delegators :@repo, :git_dir, :objects_dir, :branches, :tags, :exist?, :resolve, :ref_type
+
+  # @!attribute [r] path
+  #   @deprecated
+  #   @return [String] The path to the git cache repository
+  def path
+    logger.warn _("%{class}#path is deprecated; use #git_dir") % {class: self.class}
+    git_dir
+  end
+
+  # @!attribute [r] repo
+  #   @api private
+  attr_reader :repo
+
+  # @param remote [String] The URL of the Git remote URL to cache.
+  def initialize(remote)
+    @remote = remote
+    @repo = self.class.bare_repository.new(settings[:cache_root], sanitized_dirname)
+  end
+
+  def sync
+    if !@synced
+      sync!
+      @synced = true
+    end
+  end
+
+  def synced?
+    @synced
+  end
+
+  def sync!
+    if cached?
+      @repo.fetch
+    else
+      logger.debug1 _("Creating new git cache for %{remote}") % {remote: @remote.inspect}
+
+      # TODO extract this to an initialization step
+      if !File.exist?(settings[:cache_root])
+        FileUtils.mkdir_p settings[:cache_root]
+      end
+
+      @repo.clone(@remote)
+    end
+  end
+
+  # @api private
+  def reset!
+    @synced = false
+  end
+
+  alias cached? exist?
+
+  private
+
+  # Reformat the remote name into something that can be used as a directory
+  def sanitized_dirname
+    @remote.gsub(/[^@\w\.-]/, '-')
+  end
+end

data/lib/r10k/git/errors.rb

@@ -0,0 +1,34 @@
+require 'r10k/errors'
+
+module R10K
+  module Git
+
+    class GitError < R10K::Error
+      attr_reader :git_dir
+
+      def initialize(mesg, options = {})
+        super
+        @git_dir = @options[:git_dir]
+      end
+
+      def message
+        msg = super
+        if @git_dir
+          msg << " at #{@git_dir}"
+        end
+        msg
+      end
+    end
+
+
+    class UnresolvableRefError < GitError
+
+      attr_reader :ref
+
+      def initialize(mesg, options = {})
+        super
+        @ref = @options[:ref]
+      end
+    end
+  end
+end

data/lib/r10k/git/rugged.rb

@@ -0,0 +1,17 @@
+require 'r10k/git'
+
+begin
+  require 'rugged'
+rescue LoadError
+end
+
+module R10K
+  module Git
+    module Rugged
+      require 'r10k/git/rugged/bare_repository'
+      require 'r10k/git/rugged/working_repository'
+      require 'r10k/git/rugged/cache'
+      require 'r10k/git/rugged/thin_repository'
+    end
+  end
+end

data/lib/r10k/git/rugged/bare_repository.rb

@@ -0,0 +1,85 @@
+require 'r10k/git/rugged'
+require 'r10k/git/rugged/base_repository'
+require 'r10k/git/errors'
+
+class R10K::Git::Rugged::BareRepository < R10K::Git::Rugged::BaseRepository
+
+  # @param basedir [String] The base directory of the Git repository
+  # @param dirname [String] The directory name of the Git repository
+  def initialize(basedir, dirname)
+    @path = Pathname.new(File.join(basedir, dirname))
+
+    if exist?
+      @_rugged_repo = ::Rugged::Repository.bare(@path.to_s)
+    end
+  end
+
+  # @return [Pathname] The path to this Git repository
+  def git_dir
+    @path
+  end
+
+  # @return [Pathname] The path to the objects directory in this Git repository
+  def objects_dir
+    @path + "objects"
+  end
+
+  # Clone the given remote.
+  #
+  # This should only be called if the repository does not exist.
+  #
+  # @param remote [String] The URL of the Git remote to clone.
+  # @return [void]
+  def clone(remote)
+    logger.debug1 { _("Cloning '%{remote}' into %{path}") % {remote: remote, path: @path} }
+
+    @_rugged_repo = ::Rugged::Repository.init_at(@path.to_s, true).tap do |repo|
+      config = repo.config
+      config['remote.origin.url']    = remote
+      config['remote.origin.fetch']  = '+refs/*:refs/*'
+      config['remote.origin.mirror'] = 'true'
+    end
+
+    fetch('origin')
+  rescue Rugged::SshError, Rugged::NetworkError => e
+    raise R10K::Git::GitError.new(e.message, :git_dir => git_dir, :backtrace => e.backtrace)
+  end
+
+  # Fetch refs and objects from the origin remote
+  #
+  # @return [void]
+  def fetch(remote_name='origin')
+    logger.debug1 { _("Fetching remote '%{remote_name}' at %{path}") % {remote_name: remote_name, path: @path } }
+
+    # Check to see if we have a version of Rugged that supports "fetch --prune" and warn if not
+    if defined?(Rugged::Version) && !Gem::Dependency.new('rugged', '>= 0.24.0').match?('rugged', Rugged::Version)
+      logger.warn { _("Rugged versions prior to 0.24.0 do not support pruning stale branches during fetch, please upgrade your \'rugged\' gem. (Current version is: %{version})") % {version: Rugged::Version} }
+    end
+
+    options = {:credentials => credentials, :prune => true}
+    refspecs = ['+refs/*:refs/*']
+
+    remote = remotes[remote_name]
+    proxy = R10K::Git.get_proxy_for_remote(remote)
+    results = nil
+
+    R10K::Git.with_proxy(proxy) do
+      results = with_repo { |repo| repo.fetch(remote_name, refspecs, options) }
+    end
+
+    report_transfer(results, remote_name)
+  rescue Rugged::SshError, Rugged::NetworkError => e
+    if e.message =~ /Unsupported proxy scheme for/
+      message = e.message + "As of curl ver 7.50.2, unsupported proxy schemes no longer fall back to HTTP."
+    else
+      message = e.message
+    end
+    raise R10K::Git::GitError.new(message, :git_dir => git_dir, :backtrace => e.backtrace)
+  rescue
+    raise
+  end
+
+  def exist?
+    @path.exist?
+  end
+end

data/lib/r10k/git/rugged/base_repository.rb

@@ -0,0 +1,93 @@
+require 'r10k/git/rugged'
+require 'r10k/git/rugged/credentials'
+require 'r10k/logging'
+
+class R10K::Git::Rugged::BaseRepository
+
+  include R10K::Logging
+
+  # @return [Pathname] The path to this repository.
+  # @note The `@path` instance variable must be set by inheriting classes on instantiation.
+  attr_reader :path
+
+  def resolve(pattern)
+    object = with_repo { |repo| repo.rev_parse(pattern) }
+    case object
+    when NilClass
+      nil
+    when ::Rugged::Tag, ::Rugged::Tag::Annotation
+      object.target.oid
+    else
+      object.oid
+    end
+  rescue ::Rugged::ReferenceError
+    nil
+  end
+
+  def branches
+    with_repo { |repo| repo.branches.each_name(:local).to_a }
+  end
+
+  def tags
+    with_repo { |repo| repo.tags.each_name.to_a }
+  end
+
+  # @return [Symbol] The type of the given ref, one of :branch, :tag, :commit, or :unknown
+  def ref_type(pattern)
+    # Try to match and resolve SHA refs as quickly as possible.
+    if pattern =~ /^[0-9a-f]{5,40}$/i && @_rugged_repo.include?(pattern)
+      :commit
+    elsif @_rugged_repo.tags[pattern]
+      :tag
+    elsif @_rugged_repo.branches[pattern]
+      :branch
+    elsif resolve(pattern)
+      :commit
+    else
+      :unknown
+    end
+  end
+
+  def remotes
+    remotes_hash = {}
+
+    if @_rugged_repo
+      @_rugged_repo.remotes.each do |remote|
+        remotes_hash[remote.name] = remote.url
+      end
+    end
+
+    remotes_hash
+  end
+
+  private
+
+  def with_repo(opts={})
+    if @_rugged_repo
+      yield @_rugged_repo
+    end
+  ensure
+    @_rugged_repo.close if @_rugged_repo
+  end
+
+
+  # Generate a lambda that can create a credentials object for the
+  # authentication type in question.
+  #
+  # @note The Rugged API expects an object that responds to #call; the
+  #   Credentials subclasses implement #call returning self so that
+  #   the Credentials object can be used, or a Proc that returns a
+  #   Credentials object can be used.
+  #
+  # @api private
+  #
+  # @return [Proc]
+  def credentials
+    R10K::Git::Rugged::Credentials.new(self)
+  end
+
+  def report_transfer(results, remote)
+    logger.debug2 { "Transferred #{results[:total_objects]} objects (#{results[:received_bytes]} bytes) from '#{remote}' into #{git_dir}'" }
+    nil
+  end
+end

data/lib/r10k/git/rugged/cache.rb

@@ -0,0 +1,11 @@
+require 'r10k/git/rugged'
+require 'r10k/git/cache'
+
+class R10K::Git::Rugged::Cache < R10K::Git::Cache
+
+  @instance_cache = R10K::InstanceCache.new(self)
+
+  def self.bare_repository
+    R10K::Git::Rugged::BareRepository
+  end
+end

data/lib/r10k/git/rugged/credentials.rb

@@ -0,0 +1,91 @@
+require 'r10k/git/rugged'
+require 'r10k/git/errors'
+require 'r10k/logging'
+
+# Generate credentials for secured remote connections.
+#
+# @api private
+class R10K::Git::Rugged::Credentials
+
+  include R10K::Logging
+
+  # @param repository [R10K::Git::Rugged::BaseRepository]
+  def initialize(repository)
+    @repository = repository
+    @called = 0
+  end
+
+  def call(url, username_from_url, allowed_types)
+    @called += 1
+
+    # Break out of infinite HTTP auth retry loop introduced in libgit2/rugged 0.24.0, libssh
+    # auth seems to already abort after ~50 attempts.
+    if @called > 50
+      raise R10K::Git::GitError.new(_("Authentication failed for Git remote %{url}.") % {url: url.inspect} )
+    end
+
+    if allowed_types.include?(:ssh_key)
+      get_ssh_key_credentials(url, username_from_url)
+    elsif allowed_types.include?(:plaintext)
+      get_plaintext_credentials(url, username_from_url)
+    else
+      get_default_credentials(url, username_from_url)
+    end
+  end
+
+  def get_ssh_key_credentials(url, username_from_url)
+    user = get_git_username(url, username_from_url)
+
+    per_repo_private_key = nil
+    if per_repo_settings = R10K::Git.get_repo_settings(url)
+      per_repo_private_key = per_repo_settings[:private_key]
+    end
+
+    global_private_key = R10K::Git.settings[:private_key]
+
+    if per_repo_private_key
+      private_key = per_repo_private_key
+      logger.debug2 _("Using per-repository private key %{key} for URL %{url}") % {key: private_key, url: url.inspect}
+    elsif global_private_key
+      private_key = global_private_key
+      logger.debug2 _("URL %{url} has no per-repository private key using '%{key}'." ) % {key: private_key, url: url.inspect}
+    else
+      raise R10K::Git::GitError.new(_("Git remote %{url} uses the SSH protocol but no private key was given") % {url: url.inspect}, :git_dir => @repository.path.to_s)
+    end
+
+    if !File.readable?(private_key)
+      raise R10K::Git::GitError.new(_("Unable to use SSH key auth for %{url}: private key %{private_key} is missing or unreadable") % {url: url.inspect, private_key: private_key.inspect}, :git_dir => @repository.path.to_s)
+    end
+
+    Rugged::Credentials::SshKey.new(:username => user, :privatekey => private_key)
+  end
+
+  def get_plaintext_credentials(url, username_from_url)
+    user = get_git_username(url, username_from_url)
+    password = URI.parse(url).password || ''
+    Rugged::Credentials::UserPassword.new(username: user, password: password)
+  end
+
+  def get_default_credentials(url, username_from_url)
+    Rugged::Credentials::Default.new
+  end
+
+  def get_git_username(url, username_from_url)
+    git_user = R10K::Git.settings[:username]
+
+    user = nil
+
+    if !username_from_url.nil?
+      user = username_from_url
+      logger.debug2 _("URL %{url} includes the username %{username}, using that user for authentication.") % {url: url.inspect, username: username_from_url}
+    elsif git_user
+      user = git_user
+      logger.debug2 _("URL %{url} did not specify a user, using %{user} from configuration") % {url: url.inspect, user: user.inspect}
+    else
+      user = Etc.getlogin
+      logger.debug2 _("URL %{url} did not specify a user, using current user %{user}") % {url: url.inspect, user: user.inspect}
+    end
+
+    user
+  end
+end