r10k 1.1.4 → 1.2.0rc1

data/lib/r10k/git/tag.rb

@@ -0,0 +1,26 @@
+require 'r10k/git/ref'
+require 'r10k/git/repository'
+
+# tag: A ref under refs/tags/ namespace that points to an object of an
+# arbitrary type (typically a tag points to either a tag or a commit object).
+# In contrast to a head, a tag is not updated by the commit command. A tag is
+# most typically used to mark a particular point in the commit ancestry chain.
+#
+# @see https://www.kernel.org/pub/software/scm/git/docs/gitglossary.html
+# @api private
+class R10K::Git::Tag < R10K::Git::Ref
+
+  # @!attribute [r] tag
+  #   @return [String] The git tag
+  attr_reader :tag
+  alias :ref :tag
+
+  def initialize(tag, repository = nil)
+    @tag = tag
+    @repository = repository
+  end
+
+  def fetch?
+    ! resolvable?
+  end
+end

data/lib/r10k/git/working_dir.rb

@@ -1,15 +1,14 @@
 require 'forwardable'
 require 'r10k/logging'
+require 'r10k/git'
 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.
+# 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.
+class R10K::Git::WorkingDir < R10K::Git::Repository
 
   include R10K::Logging
 
@@ -20,124 +19,135 @@ class WorkingDir < R10K::Git::Repository
   attr_reader :cache
 
   # @!attribute [r] ref
-  #   @return [String] The git reference to use check out in the given directory
+  #   @return [R10K::Git::Ref] The git reference to use check out in the given directory
   attr_reader :ref
 
-  # Instantiates a new git synchro and optionally prepares for caching
+  # @!attribute [r] remote
+  #   @return [String] The actual remote used as an upstream for this module.
+  attr_reader :remote
+
+  # Create a new shallow git working directory
   #
-  # @param [String] ref
-  # @param [String] remote
-  # @param [String] basedir
-  # @param [String] dirname
+  # @param ref     [String, R10K::Git::Ref]
+  # @param remote  [String]
+  # @param basedir [String]
+  # @param dirname [String]
   def initialize(ref, remote, basedir, dirname = nil)
-    @ref     = ref
+
     @remote  = remote
     @basedir = basedir
     @dirname = dirname || ref
 
     @full_path = File.join(@basedir, @dirname)
+    @git_dir   = File.join(@full_path, '.git')
 
     @cache = R10K::Git::Cache.generate(@remote)
+
+    if ref.is_a? String
+      @ref = R10K::Git::Ref.new(ref, self)
+    else
+      @ref = ref
+      @ref.repository = self
+    end
   end
 
   # Synchronize the local git repository.
   def sync
-    # TODO stop forcing a sync every time.
-    @cache.sync
-
-    if cloned?
-      fetch
-    else
+    if not cloned?
       clone
+    elsif fetch?
+      fetch_from_cache
+      checkout(@ref)
+    elsif needs_checkout?
+      checkout(@ref)
+    end
+  end
+
+  def update
+    if fetch?
+      fetch_from_cache
+      checkout(@ref)
+    elsif needs_checkout?
+      checkout(@ref)
     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
+    File.directory? @git_dir
   end
+  alias :git? :cloned?
 
-  private
+  # Does a directory exist where we expect a working dir to be?
+  # @return [true, false]
+  def exist?
+    File.directory? @full_path
+  end
 
-  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"
+  # check out the given ref
+  #
+  # @param ref [R10K::Git::Ref] The git reference to check out
+  def checkout(ref)
+    if ref.resolvable?
+      git ["checkout", "--force", @ref.sha1], :path => @full_path
     else
-      git "remote set-url cache #{@cache.path}", :path => @full_path
+      raise R10K::Git::UnresolvableRefError.new(
+        "Cannot check out unresolvable ref '#{@ref}'",
+        :git_dir => @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
-    git "checkout #{@ref}", :path => @full_path
+  # The currently checked out HEAD
+  #
+  # @return [R10k::Git::Head]
+  def current
+    R10K::Git::Head.new('HEAD', self)
   end
 
-  def fetch
-    set_cache_remote
-    git "fetch --prune cache", :path => @full_path
+  def outdated?
+    @ref.fetch? or needs_checkout?
   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
+  private
 
-    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
+  def fetch?
+    @ref.fetch?
   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
+  def fetch_from_cache
+    set_cache_remote
+    @cache.sync
+    fetch('cache')
   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
+  def set_cache_remote
+    if self.remote != @cache.remote
+      git ["remote", "set-url", "cache", @cache.git_dir], :path => @full_path
+    end
+  end
 
-    remotes = {}
+  # Perform a non-bare clone of a git repository.
+  def clone
+    @cache.sync
 
-    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
+    # 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.git_dir, @remote, @full_path]
+    git ["remote", "add", "cache", @cache.git_dir], :path => @full_path
+    checkout(@ref)
+  end
 
-    remotes[remote_name]
+  def needs_fetch?
+    ref.fetch?
   end
 
-  def git_dir
-    File.join(@full_path, '.git')
+  # Does the expected ref match the actual ref?
+  def needs_checkout?
+    expected = ref.sha1
+    actual   = rev_parse('HEAD')
+
+    ! (expected == actual)
   end
 end
-end
-end

data/lib/r10k/git.rb

@@ -0,0 +1,14 @@
+module R10K
+  module Git
+    require 'r10k/git/errors'
+
+    require 'r10k/git/ref'
+    require 'r10k/git/tag'
+    require 'r10k/git/head'
+    require 'r10k/git/commit'
+
+    require 'r10k/git/repository'
+    require 'r10k/git/cache'
+    require 'r10k/git/working_dir'
+  end
+end

data/lib/r10k/module/forge.rb

@@ -1,11 +1,13 @@
 require 'r10k/module'
 require 'r10k/errors'
 require 'r10k/logging'
+require 'r10k/module/metadata'
+require 'r10k/util/subprocess'
+require 'r10k/module_repository/forge'
 
+require 'pathname'
 require 'fileutils'
-require 'systemu'
 require 'r10k/semver'
-require 'json'
 
 class R10K::Module::Forge < R10K::Module::Base
 
@@ -17,91 +19,156 @@ class R10K::Module::Forge < R10K::Module::Base
 
   include R10K::Logging
 
-  attr_accessor :owner, :full_name
+  # @!attribute [r] author
+  #   @return [String] The Forge module author
+  attr_reader :author
 
-  def initialize(name, basedir, args)
-    @full_name = name
+  # @deprecated
+  def owner
+    logger.warn "#{self.inspect}#owner is deprecated; use #author instead"
+    @author
+  end
+
+  # @!attribute [r] full_name
+  #   @return [String] The fully qualified module name
+  attr_reader :full_name
+
+  def initialize(full_name, basedir, args)
+    @full_name = full_name
     @basedir   = basedir
 
-    @owner, @name = name.split('/')
+    @author, @name = full_name.split('/')
+
+    @full_path = Pathname.new(File.join(@basedir, @name))
+
+    @metadata = R10K::Module::Metadata.new(@full_path + 'metadata.json')
 
     if args.is_a? String
-      @version = R10K::SemVer.new(args)
+      @expected_version = R10K::SemVer.new(args)
+    elsif args.is_a? Symbol and args == :latest
+      @expected_version = args
     end
   end
 
   def sync(options = {})
-    return if insync?
-
-    if insync?
-      #logger.debug1 "Module #{@full_name} already matches version #{@version}"
-    elsif File.exist? metadata_path
-      #logger.debug "Module #{@full_name} is installed but doesn't match version #{@version}, upgrading"
-
-      # A Pulp based puppetforge http://www.pulpproject.org/ wont support
-      # `puppet module install abc/xyz --version=v1.5.9` but puppetlabs forge
-      # will support `puppet module install abc/xyz --version=1.5.9`
-      #
-      # Removing v from the semver for constructing the command ensures
-      # compatibility across both
-      cmd = []
-      cmd << 'upgrade'
-      cmd << "--version=#{@version.to_s.sub(/^v/,'')}" if @version
-      cmd << "--ignore-dependencies"
-      cmd << @full_name
-      pmt cmd
-    else
-      FileUtils.mkdir @basedir unless File.directory? @basedir
-      #logger.debug "Module #{@full_name} is not installed"
-      cmd = []
-      cmd << 'install'
-      cmd << "--version=#{@version.to_s.sub(/^v/,'')}" if @version
-      cmd << "--ignore-dependencies"
-      cmd << @full_name
-      pmt cmd
+    case status
+    when :absent
+      install
+    when :outdated
+      upgrade
+    when :mismatched
+      reinstall
     end
   end
 
-  # @return [R10K::SemVer, NilClass]
-  def version
-    if metadata
-      R10K::SemVer.new(metadata['version'])
-    else
-      R10K::SemVer::MIN
+  # @return [R10K::SemVer] The expected version that the module
+  def expected_version
+    if @expected_version == :latest
+      set_version_from_forge
     end
+    @expected_version
   end
 
-  def insync?
-    @version == version
+
+  # @return [R10K::SemVer] The version of the currently installed module
+  def current_version
+    @metadata.version
   end
 
-  def metadata
-    @metadata = JSON.parse(File.read(metadata_path)) rescue nil
+  alias version current_version
+
+  def exist?
+    @full_path.exist?
   end
 
-  def metadata_path
-    File.join(full_path, 'metadata.json')
+  def insync?
+    status == :insync
+  end
+
+  # Determine the status of the forge module.
+  #
+  # @return [Symbol] :absent If the directory doesn't exist
+  # @return [Symbol] :mismatched If the module is not a forge module, or
+  #   isn't the right forge module
+  # @return [Symbol] :outdated If the installed module is older than expected
+  # @return [Symbol] :insync If the module is in the desired state
+  def status
+    if not self.exist?
+      # The module is not installed
+      return :absent
+    elsif not @metadata.exist?
+      # The directory exists but doesn't have a metadata file; it probably
+      # isn't a forge module.
+      return :mismatched
+    end
+
+    # The module is present and has a metadata file, read the metadata to
+    # determine the state of the module.
+    @metadata.read
+
+    if not @author == @metadata.author
+      # This is a forge module but the installed module is a different author
+      # than the expected author.
+      return :mismatched
+    end
+
+    if expected_version && (expected_version != @metadata.version)
+      return :outdated
+    end
+
+    return :insync
   end
 
   private
 
-  def pmt(args)
-    cmd = "puppet module --modulepath '#{@basedir}' #{args.join(' ')}"
-    log_event = "puppet module #{args.join(' ')}, modulepath: #{@basedir.inspect}"
-    logger.debug1 "Execute: #{cmd}"
+  def install
+    FileUtils.mkdir @basedir unless File.directory? @basedir
+    cmd = []
+    cmd << 'install'
+    cmd << "--version=#{expected_version}" if expected_version
+    cmd << "--ignore-dependencies"
+    cmd << @full_name
+    pmt cmd
+  end
 
-    status, stdout, stderr = systemu(cmd)
+  def upgrade
+    cmd = []
+    cmd << 'upgrade'
+    cmd << "--version=#{expected_version}" if expected_version
+    cmd << "--ignore-dependencies"
+    cmd << @full_name
+    pmt cmd
+  end
 
-    logger.debug2 "[#{log_event}] STDOUT: #{stdout.chomp}" unless stdout.empty?
-    logger.debug2 "[#{log_event}] STDERR: #{stderr.chomp}" unless stderr.empty?
+  def uninstall
+    FileUtils.rm_rf full_path
+  end
 
-    unless status == 0
-      e = R10K::ExecutionFailure.new("#{cmd.inspect} returned with non-zero exit value #{status.inspect}")
-      e.exit_code = status
-      e.stdout    = stdout
-      e.stderr    = stderr
-      raise e
-    end
-    stdout
+  def reinstall
+    uninstall
+    install
+  end
+
+  # Wrap puppet module commands
+  #
+  # @param argv [Array<String>]
+  #
+  # @return [String] The stdout from the executed command
+  def pmt(argv)
+    argv = ['puppet', 'module', '--modulepath', @basedir] + argv
+
+    subproc = R10K::Util::Subprocess.new(argv)
+    subproc.raise_on_fail = true
+    subproc.logger = self.logger
+
+    result = subproc.execute
+
+    result.stdout
+  end
+
+  def set_version_from_forge
+    repo = R10K::ModuleRepository::Forge.new
+    expected = repo.latest_version(@full_name)
+    @expected_version = R10K::SemVer.new(expected)
   end
 end