r10k 0.0.9 → 1.0.0rc1

data/lib/r10k/execution.rb

@@ -0,0 +1,43 @@
+require 'r10k/logging'
+require 'r10k/errors'
+
+require 'systemu'
+
+module R10K
+module Execution
+  include R10K::Logging
+
+  # Execute a command and return stdout
+  #
+  # @params [String] cmd
+  # @params [Hash] opts
+  #
+  # @option opts [String] :event An optional log event name. Defaults to cmd.
+  #
+  # @raise [R10K::ExecutionFailure] If the executed command exited with a
+  #   nonzero exit code.
+  #
+  # @return [String] the stdout from the command
+  def execute(cmd, opts = {})
+
+    event = opts[:event] || cmd
+
+    logger.debug1 "Execute: #{event.inspect}"
+
+    status, stdout, stderr = systemu(cmd)
+
+    logger.debug2 "[#{event}] STDOUT: #{stdout.chomp}" unless stdout.empty?
+    logger.debug2 "[#{event}] STDERR: #{stderr.chomp}" unless stderr.empty?
+
+    unless status == 0
+      msg = "#{cmd.inspect} returned with non-zero exit value #{status.exitstatus}"
+      e = R10K::ExecutionFailure.new(msg)
+      e.exit_code = status
+      e.stdout    = stdout
+      e.stderr    = stderr
+      raise e
+    end
+    stdout
+  end
+end
+end

data/lib/r10k/git/cache.rb

@@ -0,0 +1,131 @@
+require 'r10k/logging'
+require 'r10k/git/repository'
+
+module R10K
+module Git
+class Cache < R10K::Git::Repository
+  # Mirror a git repository for use shared git object repositories
+  #
+  # @see man git-clone(1)
+
+  class << self
+
+    # @!attribute [r] cache_root
+    #   @return [String] The directory to use as the cache.
+    attr_writer :cache_root
+
+    def cache_root
+      @cache_root
+    end
+
+    # Memoize class instances and return existing instances.
+    #
+    # This allows objects to mark themselves as cached to prevent unnecessary
+    # cache refreshes.
+    #
+    # @param [String] remote A git remote URL
+    # @return [R10K::Synchro::Git]
+    def new(remote)
+      @repos ||= {}
+      unless @repos[remote]
+        obj = self.allocate
+        obj.send(:initialize, remote)
+        @repos[remote] = obj
+      end
+      @repos[remote]
+    end
+
+    def clear!
+      @repos = {}
+    end
+  end
+
+  include R10K::Logging
+
+  # @!attribute [r] remote
+  #   @return [String] The git repository remote
+  attr_reader :remote
+
+  # @!attribute [r] cache_root
+  #   Where to keep the git object cache. Defaults to ~/.r10k/git if a class
+  #   level value is not set.
+  #   @return [String] The directory to use as the cache
+  attr_reader :cache_root
+
+  # @!attribute [r] path
+  #   @return [String] The path to the git cache repository
+  attr_reader :path
+
+  # @param [String] remote
+  # @param [String] cache_root
+  def initialize(remote)
+    @remote = remote
+
+    @cache_root = self.class.cache_root || default_cache_root
+
+    @path = File.join(@cache_root, sanitized_dirname)
+  end
+
+  def sync
+    if @synced
+      # XXX This gets really spammy. Might be good to turn it on later, but for
+      # general work it's way much.
+      #logger.debug "#{@remote} already synced this run, not syncing again"
+    else
+      sync!
+      @synced = true
+    end
+  end
+
+  def sync!
+    if cached?
+      # XXX This gets really spammy. Might be good to turn it on later, but for
+      # general work it's way much.
+      #logger.debug "Updating existing cache at #{@path}"
+      git "fetch --prune", :git_dir => @path
+    else
+      logger.debug "Creating new git cache for #{@remote.inspect}"
+      FileUtils.mkdir_p cache_root unless File.exist? @cache_root
+      git "clone --mirror #{@remote} #{@path}"
+    end
+  end
+
+  # @return [Array<String>] A list the branches for the git repository
+  def branches
+    output = git "branch", :git_dir => @path
+    output.split("\n").map do |str|
+      # the `git branch` command returns output like this:
+      # <pre>
+      #   0.11.x
+      #   0.12.x
+      # * master
+      #   passenger_scoping
+      # </pre>
+      #
+      # The string index notation strips off the leading whitespace/asterisk
+      str[2..-1]
+    end
+  end
+
+  # @return [true, false] If the repository has been locally cached
+  def cached?
+    File.exist? @path
+  end
+
+  private
+
+  # Reformat the remote name into something that can be used as a directory
+  def sanitized_dirname
+    @remote.gsub(/[^@\w\.-]/, '-')
+  end
+
+  def default_cache_root
+    File.expand_path('~/.r10k/git')
+  end
+
+  def git_dir
+    @path
+  end
+end
+end
+end

data/lib/r10k/git/errors.rb

@@ -0,0 +1,34 @@
+module R10K
+module Git
+  class NonexistentHashError < StandardError
+    # Raised when a hash was requested that can't be found in the repository
+
+    attr_reader :hash
+    attr_reader :git_dir
+
+    def initialize(msg = nil, git_dir = nil)
+      super(msg)
+
+      @git_dir = git_dir
+    end
+
+    HASHLIKE = %r[[A-Fa-f0-9]]
+
+    # Print a friendly error message if an object hash is given as the message
+    def message
+      msg = super
+      if msg and msg.match(HASHLIKE)
+        msg = "Could not locate hash #{msg.inspect} in repository"
+      elsif msg.nil?
+        msg = "Could not locate hash in repository"
+      end
+
+      if @git_dir
+        msg << " at #{@git_dir}. (Does the remote repository need to be updated?)"
+      end
+
+      msg
+    end
+  end
+end
+end

data/lib/r10k/git/repository.rb

@@ -0,0 +1,74 @@
+require 'r10k/execution'
+require 'r10k/git/errors'
+
+module R10K
+module Git
+class Repository
+  # Define an abstract base class for git repositories.
+
+  include R10K::Execution
+
+  # @!attribute [r] remote
+  #   @return [String] The URL to the git repository
+  attr_reader :remote
+
+  # @!attribute [r] basedir
+  #   @return [String] The basedir for the working directory
+  attr_reader :basedir
+
+  # @!attribute [r] dirname
+  #   @return [String] The name for the directory
+  attr_reader :dirname
+
+  # Resolve a ref to a commit hash
+  #
+  # @param [String] ref
+  #
+  # @return [String] The dereferenced hash of `ref`
+  def rev_parse(ref)
+    commit = git "rev-parse #{ref}^{commit}", :git_dir => git_dir
+    commit.chomp
+  rescue R10K::ExecutionFailure
+    raise R10K::Git::NonexistentHashError.new(ref, git_dir)
+  end
+
+  # Wrap git commands
+  #
+  # @param [String] command_line_args The arguments for the git prompt
+  # @param [Hash] opts
+  #
+  # @option opts [String] :git_dir
+  # @option opts [String] :work_tree
+  # @option opts [String] :work_tree
+  #
+  # @raise [R10K::ExecutionFailure] If the executed command exited with a
+  #   nonzero exit code.
+  #
+  # @return [String] The git command output
+  def git(command_line_args, opts = {})
+    args = %w{git}
+
+    log_event = "git #{command_line_args}"
+    log_event << ", args: #{opts.inspect}" unless opts.empty?
+
+
+    if opts[:path]
+      args << "--git-dir #{opts[:path]}/.git"
+      args << "--work-tree #{opts[:path]}"
+    else
+      if opts[:git_dir]
+        args << "--git-dir #{opts[:git_dir]}"
+      end
+      if opts[:work_tree]
+        args << "--work-tree #{opts[:work_tree]}"
+      end
+    end
+
+    args << command_line_args
+    cmd = args.join(' ')
+
+    execute(cmd, :event => log_event)
+  end
+end
+end
+end

data/lib/r10k/git/working_dir.rb

@@ -0,0 +1,142 @@
+require 'forwardable'
+require 'r10k/logging'
+require 'r10k/git/cache'
+
+module R10K
+module Git
+class WorkingDir < R10K::Git::Repository
+  # Implements sparse git repositories with shared objects
+  #
+  # Working directory instances use the git alternatives object store, so that
+  # working directories only contain checked out files and all object files are
+  # shared.
+
+  include R10K::Logging
+
+  extend Forwardable
+
+  # @!attribute [r] cache
+  #   @return [R10K::Git::Cache] The object cache backing this working directory
+  attr_reader :cache
+
+  # @!attribute [r] ref
+  #   @return [String] The git reference to use check out in the given directory
+  attr_reader :ref
+
+  # Instantiates a new git synchro and optionally prepares for caching
+  #
+  # @param [String] ref
+  # @param [String] remote
+  # @param [String] basedir
+  # @param [String] dirname
+  def initialize(ref, remote, basedir, dirname = nil)
+    @ref     = ref
+    @remote  = remote
+    @basedir = basedir
+    @dirname = dirname || ref
+
+    @full_path = File.join(@basedir, @dirname)
+
+    @cache = R10K::Git::Cache.new(@remote)
+  end
+
+  # Synchronize the local git repository.
+  def sync
+    # TODO stop forcing a sync every time.
+    @cache.sync
+
+    if cloned?
+      fetch
+    else
+      clone
+    end
+    reset
+  end
+
+  # Determine if repo has been cloned into a specific dir
+  #
+  # @return [true, false] If the repo has already been cloned
+  def cloned?
+    File.directory? git_dir
+  end
+
+  private
+
+  def set_cache_remote
+    # XXX This is crude but it'll ensure that the right remote is used for
+    # the cache.
+    if remote_url('cache') == @cache.path
+      logger.debug1 "Git repo #{@full_path} cache remote already set correctly"
+    else
+      git "remote set-url cache #{@cache.path}", :path => @full_path
+    end
+  end
+
+  # Perform a non-bare clone of a git repository.
+  def clone
+    # We do the clone against the target repo using the `--reference` flag so
+    # that doing a normal `git pull` on a directory will work.
+    git "clone --reference #{@cache.path} #{@remote} #{@full_path}"
+    git "remote add cache #{@cache.path}", :path => @full_path
+  end
+
+  def fetch
+    set_cache_remote
+    git "fetch --prune cache", :path => @full_path
+  end
+
+  # Reset a git repo with a working directory to a specific ref
+  def reset
+    commit  = cache.rev_parse(@ref)
+    current = rev_parse('HEAD')
+
+    if commit == current
+      logger.debug1 "Git repo #{@full_path} is already at #{commit}, no need to reset"
+      return
+    end
+
+    begin
+      git "reset --hard #{commit}", :path => @full_path
+    rescue R10K::ExecutionFailure => e
+      logger.error "Unable to locate commit object #{commit} in git repo #{@full_path}"
+      raise
+    end
+  end
+
+  # Resolve a ref to a commit hash
+  #
+  # @param [String] ref
+  #
+  # @return [String] The dereferenced hash of `ref`
+  def rev_parse(ref)
+    commit = git "rev-parse #{ref}^{commit}", :path => @full_path
+    commit.chomp
+  rescue R10K::ExecutionFailure => e
+    logger.error "Could not resolve ref #{ref.inspect} for git repo #{@full_path}"
+    raise
+  end
+
+  # @param [String] name The remote to retrieve the URl for
+  # @return [String] The git remote URL
+  def remote_url(remote_name)
+    output = git "remote -v", :path => @full_path
+
+    remotes = {}
+
+    output.each_line do |line|
+      if mdata = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)/)
+        name   = mdata[1]
+        remote = mdata[2]
+        remotes[name] = remote
+      end
+    end
+
+    remotes[remote_name]
+  end
+
+  def git_dir
+    File.join(@full_path, '.git')
+  end
+end
+end
+end

data/lib/r10k/logging.rb

@@ -7,17 +7,21 @@ module R10K::Logging
 
   include Log4r
 
+  def logger_name
+    self.class.to_s
+  end
+
   def logger
     unless @logger
-      @logger = Log4r::Logger.new(self.class.name)
+      @logger = Log4r::Logger.new(self.logger_name)
       @logger.add R10K::Logging.outputter
     end
     @logger
   end
 
   class << self
+    include Log4r
 
-  include Log4r
     def included(klass)
       unless @log4r_loaded
         Configurator.custom_levels(*%w{DEBUG2 DEBUG1 DEBUG INFO NOTICE WARN ERROR FATAL})