r10k 1.4.2 → 1.5.1

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,86 @@
+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
+
+  # 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}" }
+    @_rugged_repo = ::Rugged::Repository.init_at(@path.to_s, true)
+    with_repo do |repo|
+      config = repo.config
+      config['remote.origin.url']    = remote
+      config['remote.origin.fetch']  = '+refs/*:refs/*'
+      config['remote.origin.mirror'] = 'true'
+      fetch
+    end
+  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
+    backup_branches = wipe_branches
+    logger.debug1 { "Fetching remote 'origin' at #{@path}" }
+    options = {:credentials => credentials}
+    refspecs = ['+refs/*:refs/*']
+    results = with_repo { |repo| repo.fetch('origin', refspecs, options) }
+    report_transfer(results, 'origin')
+  rescue Rugged::SshError, Rugged::NetworkError => e
+    restore_branches(backup_branches)
+    raise R10K::Git::GitError.new(e.message, :git_dir => git_dir, :backtrace => e.backtrace)
+  rescue
+    restore_branches(backup_branches)
+    raise
+  end
+
+  def exist?
+    @path.exist?
+  end
+
+  def wipe_branches
+    backup_branches = {}
+    with_repo do |repo|
+      repo.branches.each do |branch|
+        if !branch.head?
+          backup_branches[branch.name] = branch.target_id
+          repo.branches.delete(branch)
+        end
+      end
+    end
+    backup_branches
+  end
+
+  def restore_branches(backup_branches)
+    with_repo do |repo|
+      backup_branches.each_pair do |name, ref|
+        if !repo.branches.exist?(name)
+          repo.create_branch(name, ref)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'r10k/git/rugged'
+require 'r10k/logging'
+
+class R10K::Git::Rugged::BaseRepository
+
+  include R10K::Logging
+
+  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)
+    if branches.include? pattern
+      :branch
+    elsif tags.include? pattern
+      :tag
+    elsif resolve(pattern)
+      :commit
+    else
+      :unknown
+    end
+  end
+
+  private
+
+  def with_repo
+    yield @_rugged_repo if @_rugged_repo
+  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
+    Proc.new do |url, username_from_url, allowed_types|
+      private_key = R10K::Git.settings[:private_key]
+      git_user    = R10K::Git.settings[:username]
+
+      if private_key.nil?
+        raise R10K::Git::GitError.new("Git remote #{url.inspect} uses the SSH protocol but no private key was given", :git_dir => @path.to_s)
+      end
+
+      if !username_from_url.nil?
+        user = username_from_url
+      elsif git_user
+        user = git_user
+        logger.debug1 "URL #{url.inspect} did not specify an SSH user, using #{user.inspect} from configuration"
+      else
+        user = Etc.getlogin
+        logger.debug1 "URL #{url.inspect} did not specify an SSH user, using current user #{user.inspect}"
+      end
+
+      Rugged::Credentials::SshKey.new(:username => user, :privatekey => private_key)
+    end
+  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/thin_repository.rb

@@ -0,0 +1,72 @@
+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)
+    super
+
+    if exist? && origin
+      set_cache(origin)
+    end
+  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}" }
+    set_cache(remote)
+    @cache_repo.sync
+
+    objectpath = (@cache_repo.git_dir + 'objects').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 => [objectpath])
+    alternates << objectpath
+
+    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)
+    super(@cache_repo.resolve(ref))
+  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
+
+  private
+
+  def set_cache(remote)
+    @cache_repo = R10K::Git::Rugged::Cache.generate(remote)
+  end
+end

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

@@ -0,0 +1,99 @@
+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 this directory
+  attr_reader :path
+
+  # @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))
+    if exist? && git_dir.exist?
+      @_rugged_repo = ::Rugged::Repository.new(@path.to_s, :alternates => alternates.to_a)
+    end
+  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}" }
+
+    # 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]
+    @_rugged_repo = ::Rugged::Repository.clone_at(remote, @path.to_s, options)
+
+    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)
+    logger.debug1 { "Checking out ref '#{ref}' at #{@path}" }
+    sha = resolve(ref)
+
+    with_repo do |repo|
+      repo.checkout(sha)
+      repo.reset(sha, :hard)
+    end
+  end
+
+  def fetch(remote = 'origin')
+    logger.debug1 { "Fetching remote '#{remote}' at #{@path}" }
+    options = {:credentials => credentials}
+    refspecs = ["+refs/heads/*:refs/remotes/#{remote}/*"]
+    results = with_repo { |repo| repo.fetch(remote, refspecs, options) }
+    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
+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,29 @@
+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
+
+  # @return [Pathname] The path to this Git repository
+  def git_dir
+    @path
+  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
+
+  def clone(remote)
+    git ['clone', '--mirror', remote, git_dir.to_s]
+  end
+
+  def fetch
+    git ['fetch', '--prune'], :git_dir => git_dir.to_s
+  end
+
+  def exist?
+    @path.exist?
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'r10k/git/shellgit'
+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
+
+  # @return [Array<String>] All tags in this repository
+  def tags
+    for_each_ref('refs/tags')
+  end
+
+  # @return [Symbol] The type of the given ref, one of :branch, :tag, :commit, or :unknown
+  def ref_type(pattern)
+    if branches.include? pattern
+      :branch
+    elsif tags.include? pattern
+      :tag
+    elsif resolve(pattern)
+      :commit
+    else
+      :unknown
+    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
+
+    result = subproc.execute
+
+    result
+  end
+end