r10k 3.5.2

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

@@ -0,0 +1,89 @@
+require 'r10k/git'
+require 'r10k/git/rugged/working_repository'
+require 'r10k/git/rugged/cache'
+
+class R10K::Git::Rugged::ThinRepository < R10K::Git::Rugged::WorkingRepository
+  def initialize(basedir, dirname, cache_repo)
+    @cache_repo = cache_repo
+
+    super(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
+  #
+  # @return [void]
+  def clone(remote, opts = {})
+    logger.debug1 { "Cloning '#{remote}' into #{@path}" }
+    @cache_repo.sync
+
+    cache_objects_dir = @cache_repo.objects_dir.to_s
+
+    # {Rugged::Repository.clone_at} doesn't support :alternates, which
+    # completely breaks how thin repositories need to work. To circumvent
+    # this we manually create a Git repository, set up git remotes, and
+    # update 'objects/info/alternates' with the path. We don't actually
+    # fetch any objects because we don't need them, and we don't actually
+    # use any refs in this repository so we skip all those steps.
+    ::Rugged::Repository.init_at(@path.to_s, false)
+    @_rugged_repo = ::Rugged::Repository.new(@path.to_s, :alternates => [cache_objects_dir])
+    alternates << cache_objects_dir
+
+    with_repo do |repo|
+      config = repo.config
+      config['remote.origin.url']    = remote
+      config['remote.origin.fetch']  = '+refs/heads/*:refs/remotes/origin/*'
+      config['remote.cache.url']     = @cache_repo.git_dir.to_s
+      config['remote.cache.fetch']   = '+refs/heads/*:refs/remotes/cache/*'
+    end
+
+    checkout(opts.fetch(:ref, 'HEAD'))
+  end
+
+  def checkout(ref, opts = {})
+    super(@cache_repo.resolve(ref), opts)
+  end
+
+  # Fetch refs and objects from one of the Git remotes
+  #
+  # @param remote [String] The remote to fetch, defaults to 'cache'
+  # @return [void]
+  def fetch(remote = 'cache')
+    super(remote)
+  end
+
+  # @return [String] The cache remote URL
+  def cache
+    with_repo { |repo| repo.config['remote.cache.url'] }
+  end
+
+  def tracked_paths(ref="HEAD")
+    with_repo do |repo|
+      commit = repo.rev_parse(ref)
+
+      unless commit && commit.tree
+        raise R10K::Error.new("Unable to resolve '#{ref}' to a valid commit in repo #{@path}")
+      end
+
+      commit.tree.walk(:postorder).collect do |root, entry|
+        root.empty? ? entry[:name] : File.join(root, entry[:name])
+      end
+    end
+  end
+
+  private
+
+  # Override the parent class repo setup so that we can make sure the alternates file is up to date
+  # before we create the Rugged::Repository object, which reads from the alternates file.
+  def setup_rugged_repo
+    entry_added = alternates.add?(@cache_repo.objects_dir.to_s)
+    if entry_added
+      logger.debug2 { _("Updated repo %{path} to include alternate object db path %{objects_dir}") % {path: @path, objects_dir: @cache_repo.objects_dir} }
+    end
+    super
+  end
+end

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

@@ -0,0 +1,145 @@
+require 'r10k/git/rugged'
+require 'r10k/git/rugged/base_repository'
+require 'r10k/git/errors'
+
+class R10K::Git::Rugged::WorkingRepository < R10K::Git::Rugged::BaseRepository
+
+  # @return [Pathname] The path to the Git repository inside of this directory
+  def git_dir
+    @path + '.git'
+  end
+
+  # @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))
+  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 = {})
+    logger.debug1 { _("Cloning '%{remote}' into %{path}") % {remote: remote, path: @path } }
+
+    # libgit2/rugged doesn't support cloning a repository and providing an
+    # alternate object database, making the handling of :alternates a noop.
+    # Unfortunately this means that this method can't really use alternates
+    # and running the clone will duplicate all objects in the specified
+    # repository. However alternate databases can be handled when an existing
+    # repository is loaded, so loading a cloned repo will correctly use
+    # alternate object database.
+    options = {:credentials => credentials}
+    options.merge!(:alternates => [File.join(opts[:reference], 'objects')]) if opts[:reference]
+
+    proxy = R10K::Git.get_proxy_for_remote(remote)
+
+    R10K::Git.with_proxy(proxy) do
+      @_rugged_repo = ::Rugged::Repository.clone_at(remote, @path.to_s, options)
+    end
+
+    if opts[:reference]
+      alternates << File.join(opts[:reference], 'objects')
+    end
+
+    if opts[:ref]
+      # todo:  always check out something; since we're fetching a repository we
+      # won't populate the working directory.
+      checkout(opts[:ref])
+    end
+  rescue Rugged::SshError, Rugged::NetworkError => e
+    raise R10K::Git::GitError.new(e.message, :git_dir => git_dir, :backtrace => e.backtrace)
+  end
+
+  # Check out the given Git ref
+  #
+  # @param ref [String] The git reference to check out
+  # @return [void]
+  def checkout(ref, opts = {})
+    sha = resolve(ref)
+
+    if sha
+      logger.debug2 { _("Checking out ref '%{ref}' (resolved to SHA '%{sha}') in repository %{path}") % {ref: ref, sha: sha, path: @path} }
+    else
+      raise R10K::Git::GitError.new("Unable to check out unresolvable ref '#{ref}'", git_dir: git_dir)
+    end
+
+    # :force defaults to true
+    force = !opts.has_key?(:force) || opts[:force]
+
+    with_repo do |repo|
+      # rugged/libgit2 will not update (at least) the execute bit a file if the SHA is already at
+      # the value being reset to, so this is now changed to an if ... else
+      if force
+        repo.reset(sha, :hard)
+      else
+        repo.checkout(sha)
+      end
+    end
+  end
+
+  def fetch(remote_name = 'origin')
+    logger.debug1 { _("Fetching remote '%{remote}' at %{path}") % {remote: remote_name, path: @path} }
+    options = {:credentials => credentials}
+    refspecs = ["+refs/heads/*:refs/remotes/#{remote_name}/*"]
+
+    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)
+  rescue Rugged::SshError, Rugged::NetworkError => e
+    raise R10K::Git::GitError.new(e.message, :git_dir => git_dir, :backtrace => e.backtrace)
+  end
+
+  def exist?
+    @path.exist?
+  end
+
+  def head
+    resolve('HEAD')
+  end
+
+  def alternates
+    R10K::Git::Alternates.new(git_dir)
+  end
+
+  def origin
+    with_repo { |repo| repo.config['remote.origin.url'] }
+  end
+
+  def dirty?
+    with_repo do |repo|
+      diff = repo.diff_workdir('HEAD')
+
+      diff.each_patch do |p|
+        logger.debug(_("Found local modifications in %{file_path}" % {file_path: File.join(@path, p.delta.old_file[:path])}))
+        logger.debug1(p.to_s)
+      end
+
+      return diff.size > 0
+    end
+  end
+
+  private
+
+  def with_repo
+    if @_rugged_repo.nil? && git_dir.exist?
+      setup_rugged_repo
+    end
+    super
+  end
+
+  def setup_rugged_repo
+    @_rugged_repo = ::Rugged::Repository.new(@path.to_s, :alternates => alternates.to_a)
+  end
+end

data/lib/r10k/git/shellgit.rb

@@ -0,0 +1,9 @@
+module R10K
+  module Git
+    module ShellGit
+      require 'r10k/git/shellgit/bare_repository'
+      require 'r10k/git/shellgit/working_repository'
+      require 'r10k/git/shellgit/thin_repository'
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'r10k/git/shellgit'
+require 'r10k/git/shellgit/base_repository'
+
+# Create and manage Git bare repositories.
+class R10K::Git::ShellGit::BareRepository < R10K::Git::ShellGit::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))
+  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
+
+  def clone(remote)
+    proxy = R10K::Git.get_proxy_for_remote(remote)
+
+    R10K::Git.with_proxy(proxy) do
+      git ['clone', '--mirror', remote, git_dir.to_s]
+    end
+  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'], :git_dir => git_dir.to_s
+    end
+  end
+
+  def exist?
+    @path.exist?
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'r10k/git/shellgit'
+require 'r10k/util/subprocess'
+require 'r10k/logging'
+
+class R10K::Git::ShellGit::BaseRepository
+
+  # @abstract
+  # @return [Pathname] The path to the Git directory
+  def git_dir
+    raise NotImplementedError
+  end
+
+  # Resolve the given Git ref to a commit
+  #
+  # @param pattern [String] The git ref to resolve
+  # @return [String, nil] The commit SHA if the ref could be resolved, nil otherwise.
+  def resolve(pattern)
+    result = git ['rev-parse', "#{pattern}^{commit}"], :git_dir => git_dir.to_s, :raise_on_fail => false
+    if result.success?
+      result.stdout
+    end
+  end
+
+  # For compatibility with R10K::Git::Ref
+  # @todo remove alias
+  alias rev_parse resolve
+
+  # @return [Array<String>] All local branches in this repository
+  def branches
+    for_each_ref('refs/heads')
+  end
+
+  def is_branch?(pattern)
+    result = git ['rev-parse', '-q', '--verify', "refs/heads/#{pattern}"], :git_dir => git_dir.to_s, :raise_on_fail => false
+
+    result.success?
+  end
+
+  # @return [Array<String>] All tags in this repository
+  def tags
+    for_each_ref('refs/tags')
+  end
+
+  def is_tag?(pattern)
+    result = git ['rev-parse', '-q', '--verify', "refs/tags/#{pattern}"], :git_dir => git_dir.to_s, :raise_on_fail => false
+
+    result.success?
+  end
+
+  # @return [Symbol] The type of the given ref, one of :branch, :tag, :commit, or :unknown
+  def ref_type(pattern)
+    @_ref_type_cache ||= {}
+
+    @_ref_type_cache[pattern] ||= begin
+      # Try to match and resolve SHA refs as quickly as possible.
+      if pattern =~ /^[0-9a-f]{5,40}$/i && resolve(pattern)
+        :commit
+      elsif is_tag? pattern
+        :tag
+      elsif is_branch? pattern
+        :branch
+      elsif resolve(pattern)
+        :commit
+      else
+        :unknown
+      end
+    end
+  end
+
+  # @return [Hash] Collection of remotes for this repo, keys are the remote name and values are the remote URL.
+  def remotes
+    result = git ['config', '--local', '--get-regexp', '^remote\..*\.url$'], :git_dir => git_dir.to_s, :raise_on_fail => false
+
+    if result.success?
+      Hash[
+        result.stdout.split("\n").collect do |remote|
+          matches = /^remote\.(.*)\.url (.*)$/.match(remote)
+
+          [matches[1], matches[2]]
+        end
+      ]
+    else
+      {}
+    end
+  end
+
+  include R10K::Logging
+
+  private
+
+  # @param pattern [String]
+  def for_each_ref(pattern)
+    matcher = %r[#{pattern}/(.*)$]
+    output = git ['for-each-ref', pattern, '--format', '%(refname)'], :git_dir => git_dir.to_s
+    output.stdout.scan(matcher).flatten
+  end
+
+  # Wrap git commands
+  #
+  # @param cmd [Array<String>] cmd The arguments for the git prompt
+  # @param opts [Hash] opts
+  #
+  # @option opts [String] :path
+  # @option opts [String] :git_dir
+  # @option opts [String] :work_tree
+  # @option opts [String] :raise_on_fail
+  #
+  # @raise [R10K::ExecutionFailure] If the executed command exited with a
+  #   nonzero exit code.
+  #
+  # @return [String] The git command output
+  def git(cmd, opts = {})
+    raise_on_fail = opts.fetch(:raise_on_fail, true)
+
+    argv = %w{git}
+
+    if opts[:path]
+      argv << "--git-dir"   << File.join(opts[:path], '.git')
+      argv << "--work-tree" << opts[:path]
+    else
+      if opts[:git_dir]
+        argv << "--git-dir" << opts[:git_dir]
+      end
+      if opts[:work_tree]
+        argv << "--work-tree" << opts[:work_tree]
+      end
+    end
+
+    argv.concat(cmd)
+
+    subproc = R10K::Util::Subprocess.new(argv)
+    subproc.raise_on_fail = raise_on_fail
+    subproc.logger = self.logger
+
+    subproc.execute
+  end
+end

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

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

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

@@ -0,0 +1,69 @@
+require 'r10k/git/shellgit'
+require 'r10k/git/shellgit/cache'
+require 'r10k/git/shellgit/working_repository'
+
+# Manage a Git working repository backed with cached bare repositories. Instead
+# of duplicating all objects for new clones and updates, this uses Git
+# alternate object databases to reuse objects from an existing repository,
+# making new clones very lightweight.
+class R10K::Git::ShellGit::ThinRepository < R10K::Git::ShellGit::WorkingRepository
+
+  def initialize(basedir, dirname, cache_repo)
+    @cache_repo = cache_repo
+    super(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
+  #
+  # @return [void]
+  def clone(remote, opts = {})
+    # todo check if opts[:reference] is set
+    @cache_repo.sync
+
+    super(remote, opts.merge(:reference => @cache_repo.git_dir.to_s))
+    setup_cache_remote
+  end
+
+  # Fetch refs from the backing bare Git repository.
+  def fetch(remote = 'cache')
+    git ['fetch', remote], :path => @path.to_s
+  end
+
+  # @return [String] The origin remote URL
+  def cache
+    git(['config', '--get', 'remote.cache.url'], :path => @path.to_s, :raise_on_fail => false).stdout
+  end
+
+  def tracked_paths(ref="HEAD")
+    git(['ls-tree', '-t', '-r', '--name-only', ref], :path => @path.to_s).stdout.split("\n")
+  end
+
+  private
+
+  def setup_cache_remote
+    git ["remote", "add", "cache", @cache_repo.git_dir.to_s], :path => @path.to_s
+    fetch
+  end
+
+  def git(cmd, opts = {})
+    if !@_synced_alternates
+      sync_alternates
+      @_synced_alternates = true
+    end
+    super
+  end
+
+  def sync_alternates
+    if git_dir.exist?
+      entry_added = alternates.add?(@cache_repo.objects_dir.to_s)
+      if entry_added
+        logger.debug2 { _("Updated repo %{path} to include alternate object db path %{objects_dir}") % {path: @path, objects_dir: @cache_repo.objects_dir} }
+      end
+    end
+  end
+end