r10k 2.0.3 → 2.1.0

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

@@ -4,15 +4,20 @@ 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
 
-  # @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))
+  # @return [Pathname] The path to the objects directory in this Git repository
+  def objects_dir
+    @path + "objects"
   end
 
   def clone(remote)

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

@@ -8,11 +8,14 @@ require 'r10k/git/shellgit/working_repository'
 # making new clones very lightweight.
 class R10K::Git::ShellGit::ThinRepository < R10K::Git::ShellGit::WorkingRepository
 
-  def initialize(basedir, dirname)
-    super
-
-    if exist? && origin
-      set_cache(origin)
+  def initialize(basedir, dirname, cache_repo)
+    @cache_repo = cache_repo
+    super(basedir, dirname)
+    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 #{@cache_repo.objects_dir}" }
+      end
     end
   end
 
@@ -26,7 +29,6 @@ class R10K::Git::ShellGit::ThinRepository < R10K::Git::ShellGit::WorkingReposito
   # @return [void]
   def clone(remote, opts = {})
     # todo check if opts[:reference] is set
-    set_cache(remote)
     @cache_repo.sync
 
     super(remote, opts.merge(:reference => @cache_repo.git_dir.to_s))
@@ -45,10 +47,6 @@ class R10K::Git::ShellGit::ThinRepository < R10K::Git::ShellGit::WorkingReposito
 
   private
 
-  def set_cache(remote)
-    @cache_repo = R10K::Git::ShellGit::Cache.generate(remote)
-  end
-
   def setup_cache_remote
     git ["remote", "add", "cache", @cache_repo.git_dir.to_s], :path => @path.to_s
     fetch

data/lib/r10k/git/stateful_repository.rb

@@ -25,8 +25,8 @@ class R10K::Git::StatefulRepository
     @ref = ref
     @remote = remote
 
-    @repo = R10K::Git.thin_repository.new(basedir, dirname)
     @cache = R10K::Git.cache.generate(remote)
+    @repo = R10K::Git.thin_repository.new(basedir, dirname, @cache)
   end
 
   def sync

data/lib/r10k/initializers.rb

@@ -0,0 +1,55 @@
+require 'r10k/logging'
+
+require 'r10k/git'
+require 'r10k/git/cache'
+
+require 'r10k/forge/module_release'
+
+module R10K
+  module Initializers
+    class BaseInitializer
+
+      include R10K::Logging
+
+      def initialize(settings)
+        @settings = settings
+      end
+
+      private
+
+      def with_setting(key)
+        if !@settings[key].nil?
+          yield @settings[key]
+        end
+      end
+    end
+
+    class GlobalInitializer < BaseInitializer
+      def call
+        with_setting(:purgedirs) do |_|
+          logger.warn("the purgedirs key in r10k.yaml is deprecated. it is currently ignored.")
+        end
+
+        with_setting(:cachedir) { |value| R10K::Git::Cache.settings[:cache_root] = value }
+
+        with_setting(:git) { |value| GitInitializer.new(value).call }
+        with_setting(:forge) { |value| ForgeInitializer.new(value).call }
+      end
+    end
+
+    class GitInitializer < BaseInitializer
+      def call
+        with_setting(:provider) { |value| R10K::Git.provider = value }
+        with_setting(:username) { |value| R10K::Git.settings[:username] = value }
+        with_setting(:private_key) { |value| R10K::Git.settings[:private_key] = value }
+      end
+    end
+
+    class ForgeInitializer < BaseInitializer
+      def call
+        with_setting(:proxy) { |value| R10K::Forge::ModuleRelease.settings[:proxy] = value }
+        with_setting(:baseurl) { |value| R10K::Forge::ModuleRelease.settings[:baseurl] = value }
+      end
+    end
+  end
+end

data/lib/r10k/module.rb

@@ -32,5 +32,6 @@ module R10K::Module
   require 'r10k/module/base'
   require 'r10k/module/git'
   require 'r10k/module/svn'
+  require 'r10k/module/local'
   require 'r10k/module/forge'
 end

data/lib/r10k/module/base.rb

@@ -1,4 +1,5 @@
 require 'r10k/module'
+require 'puppet_forge'
 
 # This class defines a common interface for module implementations.
 class R10K::Module::Base
@@ -36,10 +37,10 @@ class R10K::Module::Base
   # @param dirname [String]
   # @param args [Array]
   def initialize(title, dirname, args)
-    @title   = title
+    @title   = PuppetForge::V3.normalize_name(title)
     @dirname = dirname
     @args    = args
-    @owner, @name = parse_title(title)
+    @owner, @name = parse_title(@title)
     @path = Pathname.new(File.join(@dirname, @name))
   end
 

data/lib/r10k/module/forge.rb

@@ -1,13 +1,12 @@
 require 'r10k/module'
 require 'r10k/errors'
-require 'shared/puppet/module_tool/metadata'
 require 'r10k/module/metadata_file'
 
 require 'r10k/forge/module_release'
-require 'shared/puppet_forge/v3/module'
 
 require 'pathname'
 require 'fileutils'
+require 'puppet_forge'
 
 class R10K::Module::Forge < R10K::Module::Base
 
@@ -19,7 +18,7 @@ class R10K::Module::Forge < R10K::Module::Base
 
   # @!attribute [r] metadata
   #   @api private
-  #   @return [Puppet::ModuleTool::Metadata]
+  #   @return [PuppetForge::Metadata]
   attr_reader :metadata
 
   # @!attribute [r] v3_module
@@ -35,7 +34,7 @@ class R10K::Module::Forge < R10K::Module::Base
     @metadata = @metadata_file.read
 
     @expected_version = expected_version || current_version || :latest
-    @v3_module = PuppetForge::V3::Module.new(@title)
+    @v3_module = PuppetForge::V3::Module.new(:slug => @title)
   end
 
   def sync(options = {})
@@ -60,7 +59,11 @@ class R10K::Module::Forge < R10K::Module::Base
   # @return [String] The expected version that the module
   def expected_version
     if @expected_version == :latest
-      @expected_version = @v3_module.latest_version
+      begin
+      @expected_version = @v3_module.current_release.version
+      rescue Faraday::ResourceNotFound => e
+        raise PuppetForge::ReleaseNotFound, "The module #{@title} does not exist on #{PuppetForge::V3::Release.conn.url_prefix}.", e.backtrace
+      end
     end
     @expected_version
   end
@@ -85,6 +88,7 @@ class R10K::Module::Forge < R10K::Module::Base
   # @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] :mismatched If the module was previously a git checkout
   # @return [Symbol] :outdated If the installed module is older than expected
   # @return [Symbol] :insync If the module is in the desired state
   def status
@@ -97,9 +101,13 @@ class R10K::Module::Forge < R10K::Module::Base
       return :mismatched
     end
 
+    if File.directory?(@path + '.git')
+      return :mismatched
+    end
+
     # The module is present and has a metadata file, read the metadata to
     # determine the state of the module.
-    @metadata_file.read(@path + 'metadata.json')
+    @metadata = @metadata_file.read(@path + 'metadata.json')
 
     if not @title.tr('/','-') == @metadata.full_module_name.tr('/','-')
 

data/lib/r10k/module/local.rb

@@ -0,0 +1,36 @@
+require 'r10k/module'
+require 'r10k/logging'
+
+# A dummy module type that can be used to "protect" Puppet modules that exist
+# inside of the Puppetfile "moduledir" location. Local modules will not be
+# modified, and will not be purged when r10k removes unmanaged modules.
+class R10K::Module::Local < R10K::Module::Base
+
+  R10K::Module.register(self)
+
+  def self.implement?(name, args)
+    args.is_a?(Hash) && args[:local]
+  end
+
+  include R10K::Logging
+
+  def version
+    "0.0.0"
+  end
+
+  def properties
+    {
+      :expected => "0.0.0 (local)",
+      :actual   => "0.0.0 (local)",
+      :type     => :forge,
+    }
+  end
+
+  def status
+    :insync
+  end
+
+  def sync
+    logger.debug1 "Module #{title} is a local module, always indicating synced."
+  end
+end

data/lib/r10k/module/metadata_file.rb

@@ -1,6 +1,6 @@
 require 'r10k/module'
 require 'r10k/errors'
-require 'shared/puppet/module_tool/metadata'
+require 'puppet_forge'
 
 class R10K::Module::MetadataFile
 
@@ -19,7 +19,7 @@ class R10K::Module::MetadataFile
     if self.exist?
       metadata_file_path.open do |f|
         begin
-          metadata = Puppet::ModuleTool::Metadata.new
+          metadata = PuppetForge::Metadata.new
           metadata.update(JSON.load(f), false)
         rescue JSON::ParserError => e
           exception = R10K::Error.wrap(e, "Could not read metadata.json")

data/lib/r10k/puppetfile.rb

@@ -51,7 +51,7 @@ class Puppetfile
   def load!
     dsl = R10K::Puppetfile::DSL.new(self)
     dsl.instance_eval(puppetfile_contents, @puppetfile_path)
-  rescue SyntaxError, LoadError => e
+  rescue SyntaxError, LoadError, ArgumentError => e
     raise R10K::Error.wrap(e, "Failed to evaluate #{@puppetfile_path}")
   end
 

data/lib/r10k/settings.rb

@@ -1,6 +1,92 @@
+require 'etc'
+
 module R10K
   module Settings
     require 'r10k/settings/container'
     require 'r10k/settings/mixin'
+
+    require 'r10k/settings/collection'
+    require 'r10k/settings/definition'
+
+    def self.git_settings
+      R10K::Settings::Collection.new(:git, [
+
+        EnumDefinition.new(:provider, {
+          :desc => "The Git provider to use. Valid values: 'shellgit', 'rugged'",
+          :normalize => lambda { |input| input.to_sym },
+          :enum => [:shellgit, :rugged],
+        }),
+
+        Definition.new(:username, {
+          :desc => "The username to use for Git SSH remotes that do not specify a user.
+                    Only used by the 'rugged' Git provider.
+                    Default: the current user",
+          :default => lambda { Etc.getlogin },
+        }),
+
+        Definition.new(:private_key, {
+          :desc => "The path to the SSH private key for Git SSH remotes.
+                    Only used by the 'rugged' Git provider.",
+        })
+      ])
+    end
+
+    def self.forge_settings
+      R10K::Settings::Collection.new(:forge, [
+        URIDefinition.new(:proxy, {
+          :desc => "An optional proxy server to use when downloading modules from the forge.",
+        }),
+
+        URIDefinition.new(:baseurl, {
+          :desc => "The URL to the Puppet Forge to use for downloading modules."
+        }),
+      ])
+    end
+
+    def self.deploy_settings
+      R10K::Settings::Collection.new(:deploy, [
+        Definition.new(:write_lock, {
+          :desc => "Whether r10k deploy actions should be locked out in case r10k is being managed
+          by another application. The value should be a string containing the reason for the write lock.",
+          :validate => lambda do |value|
+            if value && !value.is_a?(String)
+              raise ArgumentError, "The write_lock setting should be a string containing the reason for the write lock, not a #{value.class}"
+            end
+          end
+        }),
+      ])
+    end
+
+    def self.global_settings
+      R10K::Settings::Collection.new(:global, [
+        Definition.new(:sources, {
+          :desc => "Where r10k should retrieve sources when deploying environments.
+                    Only used for r10k environment deployment.",
+        }),
+
+        Definition.new(:purgedirs, {
+          :desc => "The purgedirs setting was deprecated in r10k 1.0.0 and is no longer respected.",
+        }),
+
+        Definition.new(:cachedir, {
+          :desc => "Where r10k should store cached Git repositories.",
+        }),
+
+        Definition.new(:postrun, {
+          :desc => "The command r10k should run after deploying environments.",
+          :validate => lambda do |value|
+            if !value.is_a?(Array)
+              raise ArgumentError, "The postrun setting should be an array of strings, not a #{value.class}"
+            end
+          end
+        }),
+
+        R10K::Settings.forge_settings,
+
+        R10K::Settings.git_settings,
+
+        R10K::Settings.deploy_settings,
+      ])
+    end
   end
 end

data/lib/r10k/settings/collection.rb

@@ -0,0 +1,118 @@
+require 'r10k/settings/definition'
+require 'r10k/util/setopts'
+require 'r10k/util/symbolize_keys'
+require 'r10k/errors'
+
+module R10K
+  module Settings
+
+    # Define a group of settings, which can be single definitions or nested
+    # collections.
+    class Collection
+
+      # @!attribute [r] name
+      #   @return [String] The name of this collection
+      attr_reader :name
+
+      # @param name [Symbol] The name of the collection
+      # @param settings [Array] All settings in this collection
+      def initialize(name, settings)
+        @name = name
+        @settings = Hash[settings.map { |s| [s.name, s] }]
+      end
+
+      # Assign new values, perform validation checks, and return the final
+      # values for this collection
+      def evaluate(newvalues)
+        assign(newvalues)
+        validate
+        resolve
+      end
+
+      # Assign a hash of values to the settings in this collection.
+      #
+      # If the passed hash contains any invalid settings values, the names
+      # of those settings are stored for use in the {#validate} method.
+      #
+      # @param newvalues [Hash]
+      # @return [void]
+      def assign(newvalues)
+        return if newvalues.nil?
+
+        R10K::Util::SymbolizeKeys.symbolize_keys!(newvalues)
+        @settings.each_pair do |name, setting|
+          if newvalues.key?(name)
+            setting.assign(newvalues[name])
+          end
+        end
+      end
+
+      # Validate all settings and return validation errors
+      #
+      # @return [nil, Hash] If all validation passed nil will be returned; if
+      #   validation failed then a hash of those errors will be returned.
+      def validate
+        errors = {}
+
+        @settings.each_pair do |name, setting|
+          begin
+            setting.validate
+          rescue => error
+            errors[name] = error
+          end
+        end
+
+        if !errors.empty?
+          raise ValidationError.new("Validation failed for #{@name} settings group", :errors => errors)
+        end
+      end
+
+      # Evaluate all settings and return a frozen hash of the final values.
+      # @return [Hash]
+      def resolve
+        rv = {}
+        @settings.each_pair do |name, setting|
+          rv[name] = setting.resolve
+        end
+        rv.freeze
+      end
+
+      class ValidationError < R10K::Error
+
+        attr_reader :errors
+
+        def initialize(mesg, options = {})
+          super
+          @errors = options[:errors]
+        end
+
+        def format
+          struct = []
+          struct << "#{message}:"
+          @errors.each_pair do |name, nested|
+            struct << indent(structure_exception(name, nested))
+          end
+          struct.join("\n")
+        end
+
+        private
+
+        def structure_exception(name, exc)
+          struct = []
+          struct << "#{name}:"
+          if exc.is_a? ValidationError
+            struct << indent(exc.format)
+          else
+            struct << indent(exc.message)
+          end
+          struct.join("\n")
+        end
+
+        def indent(str, level = 4)
+          prefix = ' ' * level
+          str.gsub(/^/, prefix)
+        end
+      end
+    end
+  end
+end