akerl-r10k 3.14.2.1

data/lib/r10k/logging.rb

@@ -0,0 +1,186 @@
+require 'r10k'
+require 'forwardable'
+
+require 'log4r'
+require 'log4r/configurator'
+require 'r10k/logging/terminaloutputter'
+
+module R10K::Logging
+
+  LOG_LEVELS = %w{DEBUG2 DEBUG1 DEBUG INFO NOTICE WARN ERROR FATAL}
+  SYSLOG_LEVELS_MAP = {
+    'DEBUG2' => 'DEBUG',
+    'DEBUG1' => 'DEBUG',
+    'DEBUG' => 'DEBUG',
+    'INFO' => 'INFO',
+    'NOTICE' => 'INFO',
+    'WARN' => 'WARN',
+    'ERROR' => 'ERROR',
+    'FATAL' => 'FATAL',
+  }.freeze
+
+  def logger_name
+    self.class.to_s
+  end
+
+  def logger
+    if @logger.nil?
+      name = logger_name
+      if Log4r::Logger[name]
+        @logger = Log4r::Logger[name]
+      else
+        @logger = Log4r::Logger.new(name)
+        @logger.add(R10K::Logging.outputter)
+        R10K::Logging.outputters.each do |output|
+          @logger.add(output)
+        end
+      end
+    end
+    @logger
+  end
+
+  class << self
+
+    # Convert the input to a valid Log4r log level
+    #
+    # @param input [String, TrueClass] The level to parse. If TrueClass then
+    #   Log4r::INFO will be returned (indicating a generic raised verbosity),
+    #   if a string it will be parsed either as a numeric value or a textual
+    #   log level.
+    # @api private
+    # @return [Integer, NilClass] The numeric log level, or nil if the log
+    #   level is invalid.
+    def parse_level(input)
+      case input
+      when TrueClass
+        Log4r::INFO
+      when /\A\d+\Z/
+        Integer(input)
+      when String
+        const_name = input.upcase
+        if LOG_LEVELS.include?(const_name)
+          begin
+            Log4r.const_get(const_name.to_sym)
+          rescue NameError
+          end
+        end
+      end
+    end
+
+    def level=(val)
+      level = parse_level(val)
+      if level.nil?
+        raise ArgumentError, _("Invalid log level '%{val}'. Valid levels are %{log_levels}") % {val: val, log_levels: LOG_LEVELS.map(&:downcase).inspect}
+      end
+      outputter.level = level unless @disable_default_stderr
+      @level = level
+
+      if level < Log4r::INFO
+        outputter.formatter = debug_formatter
+      else
+        outputter.formatter = default_formatter
+      end
+    end
+
+    def disable_default_stderr=(val)
+      @disable_default_stderr = val
+      outputter.level = val ? Log4r::OFF : @level
+    end
+
+    def add_outputters(outputs)
+      outputs.each do |output|
+        type = output.fetch(:type)
+        # Support specifying both short as well as full names
+        type = type.to_s[0..-10] if type.to_s.downcase.end_with? 'outputter'
+
+        name = output.fetch(:name, 'r10k')
+        if output[:level]
+          level = parse_level(output[:level])
+          if level.nil?
+            raise ArgumentError, _("Invalid log level '%{val}'. Valid levels are %{log_levels}") % { val: output[:level], log_levels: LOG_LEVELS.map(&:downcase).inspect }
+          end
+        else
+          level = self.level
+        end
+        only_at = output[:only_at]
+        only_at&.map! do |val|
+          lv = parse_level(val)
+          if lv.nil?
+            raise ArgumentError, _("Invalid log level '%{val}'. Valid levels are %{log_levels}") % { val: val, log_levels: LOG_LEVELS.map(&:downcase).inspect }
+          end
+
+          lv
+        end
+        parameters = output.fetch(:parameters, {}).merge({ level: level })
+
+        begin
+          # Try to load the outputter file if possible
+          require "log4r/outputter/#{type.to_s.downcase}outputter"
+        rescue LoadError
+          false
+        end
+        outputtertype = Log4r.constants
+                             .select { |klass| klass.to_s.end_with? 'Outputter' }
+                             .find { |klass| klass.to_s.downcase == "#{type.to_s.downcase}outputter" }
+        raise ArgumentError, "Unable to find a #{output[:type]} outputter." unless outputtertype
+
+        outputter = Log4r.const_get(outputtertype).new(name, parameters)
+        outputter.only_at(*only_at) if only_at
+        # Handle log4r's syslog mapping correctly
+        outputter.map_levels_by_name_to_syslog(SYSLOG_LEVELS_MAP) if outputter.respond_to? :map_levels_by_name_to_syslog
+
+        @outputters << outputter
+        Log4r::Logger.global.add outputter
+      end
+    end
+
+    extend Forwardable
+    def_delegators :@outputter, :use_color, :use_color=
+
+    # @!attribute [r] level
+    #   @return [Integer] The current log level. Lower numbers correspond
+    #     to more verbose log levels.
+    attr_reader :level
+
+    # @!attribute [r] formatter
+    #   @api private
+    #   @return [Log4r::Formatter]
+    attr_reader :formatter
+
+    # @!attribute [r] outputter
+    #   @api private
+    #   @return [Log4r::Outputter]
+    attr_reader :outputter
+
+    # @!attribute [r] outputters
+    #   @api private
+    #   @return [Array[Log4r::Outputter]]
+    attr_reader :outputters
+
+    # @!attribute [r] disable_default_stderr
+    #   @api private
+    #   @return [Boolean]
+    attr_reader :disable_default_stderr
+
+    def default_formatter
+      Log4r::PatternFormatter.new(:pattern => '%l\t -> %m')
+    end
+
+    def debug_formatter
+      Log4r::PatternFormatter.new(:pattern => '[%d - %l] %m')
+    end
+
+    def default_outputter
+      R10K::Logging::TerminalOutputter.new('terminal', $stderr, :level => self.level, :formatter => formatter)
+    end
+  end
+
+  Log4r::Configurator.custom_levels(*LOG_LEVELS)
+  Log4r::Logger.global.level = Log4r::ALL
+
+  @level     = Log4r::WARN
+  @formatter = default_formatter
+  @outputter = default_outputter
+  @outputters = []
+  @disable_default_stderr = false
+end

data/lib/r10k/module/base.rb

@@ -0,0 +1,182 @@
+require 'r10k/module'
+require 'r10k/logging'
+require 'puppet_forge'
+
+# This class defines a common interface for module implementations.
+class R10K::Module::Base
+
+  include R10K::Logging
+
+  # @!attribute [r] title
+  #   @return [String] The forward slash separated owner and name of the module
+  attr_reader :title
+
+  # @!attribute [r] name
+  #   @return [String] The name of the module
+  attr_reader :name
+
+  # @param [r] dirname
+  #   @return [String] The name of the directory containing this module
+  attr_reader :dirname
+
+  # @deprecated
+  alias :basedir :dirname
+
+  # @!attribute [r] owner
+  #   @return [String, nil] The owner of the module if one is specified
+  attr_reader :owner
+
+  # @!attribute [r] path
+  #   @return [Pathname] The full path of the module
+  attr_reader :path
+
+  # @!attribute [r] environment
+  #   @return [R10K::Environment, nil] The parent environment of the module
+  attr_reader :environment
+
+  # @!attribute [rw] origin
+  #   @return [String] Where the module was sourced from. E.g., "Puppetfile"
+  attr_accessor :origin
+
+  # @!attribute [rw] spec_deletable
+  #   @return [Boolean] set this to true if the spec dir can be safely removed, ie in the moduledir
+  attr_accessor :spec_deletable
+
+  # There's been some churn over `author` vs `owner` and `full_name` over
+  # `title`, so in the short run it's easier to support both and deprecate one
+  # later.
+  alias :author :owner
+  alias :full_name :title
+
+  # @param title [String]
+  # @param dirname [String]
+  # @param args [Hash]
+  def initialize(title, dirname, args, environment=nil)
+    @title   = PuppetForge::V3.normalize_name(title)
+    @dirname = dirname
+    @args    = args
+    @owner, @name = parse_title(@title)
+    @path = Pathname.new(File.join(@dirname, @name))
+    @environment = environment
+    @overrides = args.delete(:overrides) || {}
+    @spec_deletable = true
+    @exclude_spec = false
+    @exclude_spec = @overrides.dig(:modules, :exclude_spec) if @overrides.dig(:modules, :exclude_spec)
+    if args.has_key?(:exclude_spec)
+      logger.debug2 _("Overriding :exclude_spec setting with per module setting for #{@title}")
+      @exclude_spec = args.delete(:exclude_spec)
+    end
+    @origin = 'external' # Expect Puppetfile or R10k::Environment to set this to a specific value
+
+    @requested_modules = @overrides.dig(:modules, :requested_modules) || []
+    @should_sync = (@requested_modules.empty? || @requested_modules.include?(@name))
+  end
+
+  # @deprecated
+  # @return [String] The full filesystem path to the module.
+  def full_path
+    path.to_s
+  end
+
+  # Delete the spec dir if @exclude_spec has been set to true and @spec_deletable is also true
+  def maybe_delete_spec_dir
+    if @exclude_spec
+      if @spec_deletable
+        delete_spec_dir
+      else
+        logger.info _("Spec dir for #{@title} will not be deleted because it is not in the moduledir")
+      end
+    end
+  end
+
+  # Actually remove the spec dir
+  def delete_spec_dir
+    spec_path = @path + 'spec'
+    if spec_path.symlink?
+      spec_path = spec_path.realpath
+    end
+    if spec_path.directory?
+      logger.debug2 _("Deleting spec data at #{spec_path}")
+      # Use the secure flag for the #rm_rf method to avoid security issues
+      # involving TOCTTOU(time of check to time of use); more details here:
+      # https://ruby-doc.org/stdlib-2.7.0/libdoc/fileutils/rdoc/FileUtils.html#method-c-rm_rf
+      # Additionally, #rm_rf also has problems in windows with with symlink targets
+      # also being deleted; this should be revisted if Windows becomes higher priority.
+      FileUtils.rm_rf(spec_path, secure: true)
+    else
+      logger.debug2 _("No spec dir detected at #{spec_path}, skipping deletion")
+    end
+  end
+
+  # Synchronize this module with the indicated state.
+  # @param [Hash] opts Deprecated
+  # @return [Boolean] true if the module was updated, false otherwise
+  def sync(opts={})
+    raise NotImplementedError
+  end
+
+  def should_sync?
+    if @should_sync
+      logger.info _("Deploying module to %{path}") % {path: path}
+      true
+    else
+      logger.debug1(_("Only updating modules %{modules}, skipping module %{name}") % {modules: @requested_modules.inspect, name: name})
+      false
+    end
+  end
+
+
+  # Return the desired version of this module
+  # @abstract
+  def version
+    raise NotImplementedError
+  end
+
+  # Return the status of the currently installed module.
+  #
+  # This can return the following values:
+  #
+  #   * :absent - there is no module installed
+  #   * :mismatched - there is a module installed but it must be removed and reinstalled
+  #   * :outdated - the correct module is installed but it needs to be updated
+  #   * :insync - the correct module is installed and up to date, or the module is actually a boy band.
+  #
+  # @return [Symbol]
+  # @abstract
+  def status
+    raise NotImplementedError
+  end
+
+  # Deprecated
+  def accept(visitor)
+    visitor.visit(:module, self)
+  end
+
+  # Return the properties of the module
+  #
+  # @return [Hash]
+  # @abstract
+  def properties
+    raise NotImplementedError
+  end
+
+  # Return the module's cachedir. Subclasses that implement a cache
+  # will override this to return a real directory location.
+  #
+  # @return [String, :none]
+  def cachedir
+    :none
+  end
+
+  private
+
+  def parse_title(title)
+    if (match = title.match(/\A(\w+)\Z/))
+      [nil, match[1]]
+    elsif (match = title.match(/\A(\w+)[-\/](\w+)\Z/))
+      [match[1], match[2]]
+    else
+      raise ArgumentError, _("Module name (%{title}) must match either 'modulename' or 'owner/modulename'") % {title: title}
+    end
+  end
+end

data/lib/r10k/module/definition.rb

@@ -0,0 +1,64 @@
+require 'r10k/module'
+
+class R10K::Module::Definition < R10K::Module::Base
+
+  attr_reader :version
+
+  def initialize(name, dirname:, args:, implementation:, environment: nil)
+    @original_name  = name
+    @original_args  = args.dup
+    @implementation = implementation
+    @version        = implementation.statically_defined_version(name, args)
+
+    super(name, dirname, args, environment)
+  end
+
+  def to_implementation
+    mod = @implementation.new(@title, @dirname, @original_args, @environment)
+
+    mod.origin = origin
+    mod.spec_deletable = spec_deletable
+
+    mod
+  end
+
+  # syncing is a noop for module definitions
+  # Returns false to inidicate the module was not updated
+  def sync(args = {})
+    logger.debug1(_("Not updating module %{name}, assuming content unchanged") % {name: name})
+    false
+  end
+
+  def status
+    :insync
+  end
+
+  def properties
+    type = nil
+
+    if @args[:type]
+      type = @args[:type]
+    elsif @args[:ref] || @args[:commit] || @args[:branch] || @args[:tag]
+      type = 'git'
+    elsif @args[:svn]
+      # This logic is clear and included for completeness sake, though at
+      # this time module definitions do not support SVN versions.
+      type = 'svn'
+    else
+      type = 'forge'
+    end
+
+    {
+      expected: version,
+      # We can't get the value for `actual` here because that requires the
+      # implementation (and potentially expensive operations by the
+      # implementation). Some consumers will check this value, if it exists
+      # and if not, fall back to the expected version. That is the correct
+      # behavior when assuming modules are unchanged, and why `actual` is set
+      # to `nil` here.
+      actual: nil,
+      type: type
+    }
+  end
+end
+

data/lib/r10k/module/forge.rb

@@ -0,0 +1,208 @@
+require 'r10k/module'
+require 'r10k/errors'
+require 'r10k/module/metadata_file'
+
+require 'r10k/forge/module_release'
+
+require 'pathname'
+require 'fileutils'
+require 'puppet_forge/util'
+
+class R10K::Module::Forge < R10K::Module::Base
+
+  R10K::Module.register(self)
+
+  def self.implement?(name, args)
+    args[:type].to_s == 'forge'
+  end
+
+  def self.statically_defined_version(name, args)
+    args[:version] if args[:version].is_a?(String)
+  end
+
+  # @!attribute [r] metadata
+  #   @api private
+  #   @return [PuppetForge::Metadata]
+  attr_reader :metadata
+
+  # @!attribute [r] v3_module
+  #   @api private
+  #   @return [PuppetForge::V3::Module] The Puppet Forge module metadata
+  attr_reader :v3_module
+
+  include R10K::Util::Setopts
+
+  def initialize(title, dirname, opts, environment=nil)
+    super
+
+    @metadata_file = R10K::Module::MetadataFile.new(path + 'metadata.json')
+    @metadata = @metadata_file.read
+
+    setopts(opts, {
+      # Standard option interface
+      :version => :expected_version,
+      :source  => ::R10K::Util::Setopts::Ignore,
+      :type    => ::R10K::Util::Setopts::Ignore,
+    }, :raise_on_unhandled => false)
+
+    # Validate version and raise on issue. Title is validated by base class.
+    unless valid_version?(@expected_version)
+      raise ArgumentError, _("Module version %{ver} is not a valid Forge module version") % {ver: @expected_version}
+    end
+
+    @expected_version ||= current_version || :latest
+
+    @v3_module = PuppetForge::V3::Module.new(:slug => @title)
+  end
+
+  def valid_version?(version)
+    version == :latest || version.nil? || PuppetForge::Util.version_valid?(version)
+  end
+
+  # @param [Hash] opts Deprecated
+  # @return [Boolean] true if the module was updated, false otherwise
+  def sync(opts={})
+    updated = false
+    if should_sync?
+      case status
+      when :absent
+        install
+        updated = true
+      when :outdated
+        upgrade
+        updated = true
+      when :mismatched
+        reinstall
+        updated = true
+      end
+      maybe_delete_spec_dir
+    end
+    updated
+  end
+
+  def properties
+    {
+      :expected => expected_version,
+      :actual   => current_version,
+      :type     => :forge,
+    }
+  end
+
+  # @return [String] The expected version that the module
+  def expected_version
+    if @expected_version == :latest
+      begin
+        if @v3_module.current_release
+          @expected_version = @v3_module.current_release.version
+        else
+          raise PuppetForge::ReleaseNotFound, _("The module %{title} does not appear to have any published releases, cannot determine latest version.") % { title: @title }
+        end
+      rescue Faraday::ResourceNotFound => e
+        raise PuppetForge::ReleaseNotFound, _("The module %{title} does not exist on %{url}.") % {title: @title, url: PuppetForge::V3::Release.conn.url_prefix}, e.backtrace
+      end
+    end
+    @expected_version
+  end
+
+  # @return [String] The version of the currently installed module
+  def current_version
+    if insync?
+      (@metadata ||= @metadata_file.read).nil? ? nil : @metadata.version
+    else
+      nil
+    end
+  end
+
+  alias version current_version
+
+  def exist?
+    path.exist?
+  end
+
+  def insync?
+    status == :insync
+  end
+
+  def deprecated?
+    begin
+      @v3_module.fetch && @v3_module.has_attribute?('deprecated_at') && !@v3_module.deprecated_at.nil?
+    rescue Faraday::ResourceNotFound => e
+      raise PuppetForge::ReleaseNotFound, _("The module %{title} does not exist on %{url}.") % {title: @title, url: PuppetForge::V3::Release.conn.url_prefix}, e.backtrace
+    end
+  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] :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
+    if not self.exist?
+      # The module is not installed
+      return :absent
+    elsif not File.exist?(@path + 'metadata.json')
+      # The directory exists but doesn't have a metadata file; it probably
+      # isn't a forge module.
+      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 = @metadata_file.read(@path + 'metadata.json')
+
+    if not @title.tr('/','-') == @metadata.full_module_name.tr('/','-')
+
+      # 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
+
+  def install
+    if deprecated?
+      logger.warn "Puppet Forge module '#{@v3_module.slug}' has been deprecated, visit https://forge.puppet.com/#{@v3_module.slug.tr('-','/')} for more information."
+    end
+
+    parent_path = @path.parent
+    if !parent_path.exist?
+      parent_path.mkpath
+    end
+    module_release = R10K::Forge::ModuleRelease.new(@title, expected_version)
+    module_release.install(@path)
+  end
+
+  alias upgrade install
+
+  def uninstall
+    FileUtils.rm_rf full_path
+  end
+
+  def reinstall
+    uninstall
+    install
+  end
+
+  private
+
+  # Override the base #parse_title to ensure we have a fully qualified name
+  def parse_title(title)
+    if (match = title.match(/\A(\w+)[-\/](\w+)\Z/))
+      [match[1], match[2]]
+    else
+      raise ArgumentError, _("Forge module names must match 'owner/modulename', instead got #{title}")
+    end
+  end
+end