openvox 8.19.0

data/install.rb

@@ -0,0 +1,428 @@
+#! /usr/bin/env ruby
+#--
+# Copyright 2004 Austin Ziegler <ruby-install@halostatue.ca>
+#   Install utility. Based on the original installation script for rdoc by the
+#   Pragmatic Programmers.
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later) or the Ruby licence.
+#
+# Usage
+# -----
+# In most cases, if you have a typical project layout, you will need to do
+# absolutely nothing to make this work for you. This layout is:
+#
+#   bin/    # executable files -- "commands"
+#   lib/    # the source of the library
+#
+# The default behaviour:
+# 1) Build Rdoc documentation from all files in bin/ (excluding .bat and .cmd),
+#    all .rb files in lib/, ./README, ./ChangeLog, and ./Install.
+# 2) Build ri documentation from all files in bin/ (excluding .bat and .cmd),
+#    and all .rb files in lib/. This is disabled by default on Microsoft Windows.
+# 3) Install commands from bin/ into the Ruby bin directory. On Windows, if a
+#    if a corresponding batch file (.bat or .cmd) exists in the bin directory,
+#    it will be copied over as well. Otherwise, a batch file (always .bat) will
+#    be created to run the specified command.
+# 4) Install all library files ending in .rb from lib/ into Ruby's
+#    site_lib/version directory.
+#
+#++
+
+require 'rbconfig'
+require 'find'
+require 'fileutils'
+require 'tempfile'
+require 'optparse'
+require 'ostruct'
+
+PREREQS = %w{openssl facter cgi}
+MIN_FACTER_VERSION = 1.5
+
+InstallOptions = OpenStruct.new
+
+def glob(list)
+  g = list.map { |i| Dir.glob(i) }
+  g.flatten!
+  g.compact!
+  g
+end
+
+def do_configs(configs, target, strip = 'conf/')
+  Dir.mkdir(target) unless File.directory? target
+  configs.each do |cf|
+    ocf = File.join(InstallOptions.config_dir, cf.gsub(/#{strip}/, ''))
+    FileUtils.install(cf, ocf, mode: 0644, preserve: true, verbose: true)
+  end
+end
+
+def do_bins(bins, target, strip = 's?bin/')
+  Dir.mkdir(target) unless File.directory? target
+  bins.each do |bf|
+    obf = bf.gsub(/#{strip}/, '')
+    install_binfile(bf, obf, target)
+  end
+end
+
+def do_libs(libs, strip = 'lib/')
+  libs.each do |lf|
+    next if File.directory? lf
+    olf = File.join(InstallOptions.site_dir, lf.sub(/^#{strip}/, ''))
+    op = File.dirname(olf)
+    FileUtils.makedirs(op, mode: 0755, verbose: true)
+    FileUtils.chmod(0755, op)
+    FileUtils.install(lf, olf, mode: 0644, preserve: true, verbose: true)
+  end
+end
+
+def do_man(man, strip = 'man/')
+  man.each do |mf|
+    omf = File.join(InstallOptions.man_dir, mf.gsub(/#{strip}/, ''))
+    om = File.dirname(omf)
+    FileUtils.makedirs(om, mode: 0755, verbose: true)
+    FileUtils.chmod(0755, om)
+    FileUtils.install(mf, omf, mode: 0644, preserve: true, verbose: true)
+    # Solaris does not support gzipped man pages. When called with
+    # --no-check-prereqs/without facter the default gzip behavior still applies
+    unless $osname == "Solaris"
+      gzip = %x{which gzip}
+      gzip.chomp!
+      %x{#{gzip} --force --no-name #{omf}}
+    end
+  end
+end
+
+def do_locales(locale, strip = 'locales/')
+  locale.each do |lf|
+    next if File.directory? lf
+    olf = File.join(InstallOptions.locale_dir, lf.sub(/^#{strip}/, ''))
+    op = File.dirname(olf)
+    FileUtils.makedirs(op, mode: 0755, verbose: true)
+    FileUtils.chmod(0755, op)
+    FileUtils.install(lf, olf, mode: 0644, preserve: true, verbose: true)
+  end
+end
+
+# Verify that all of the prereqs are installed
+def check_prereqs
+  PREREQS.each { |pre|
+    begin
+      require pre
+      if pre == "facter"
+        # to_f isn't quite exact for strings like "1.5.1" but is good
+        # enough for this purpose.
+        facter_version = Facter.version.to_f
+        if facter_version < MIN_FACTER_VERSION
+          puts "Facter version: #{facter_version}; minimum required: #{MIN_FACTER_VERSION}; cannot install"
+          exit(-1)
+        end
+      end
+    rescue LoadError
+      puts "Could not load #{pre}; cannot install"
+      exit(-1)
+    end
+  }
+end
+
+##
+# Prepare the file installation.
+#
+def prepare_installation
+  InstallOptions.configs = true
+  InstallOptions.check_prereqs = true
+  InstallOptions.batch_files = true
+
+  ARGV.options do |opts|
+    opts.banner = "Usage: #{File.basename($0)} [options]"
+    opts.separator ""
+    opts.on('--[no-]configs', 'Prevents the installation of config files', 'Default off.') do |ontest|
+      InstallOptions.configs = ontest
+    end
+    opts.on('--destdir[=OPTIONAL]', 'Installation prefix for all targets', 'Default essentially /') do |destdir|
+      InstallOptions.destdir = destdir
+    end
+    opts.on('--configdir[=OPTIONAL]', 'Installation directory for config files', 'Default /etc/puppetlabs/puppet') do |configdir|
+      InstallOptions.configdir = configdir
+    end
+    opts.on('--codedir[=OPTIONAL]', 'Installation directory for code files', 'Default /etc/puppetlabs/code') do |codedir|
+      InstallOptions.codedir = codedir
+    end
+    opts.on('--vardir[=OPTIONAL]', 'Installation directory for var files', 'Default /opt/puppetlabs/puppet/cache') do |vardir|
+      InstallOptions.vardir = vardir
+    end
+    opts.on('--publicdir[=OPTIONAL]', 'Installation directory for public files such as the `last_run_summary.yaml` report', 'Default /opt/puppetlabs/puppet/public') do |publicdir|
+      InstallOptions.publicdir = publicdir
+    end
+    opts.on('--rundir[=OPTIONAL]', 'Installation directory for state files', 'Default /var/run/puppetlabs') do |rundir|
+      InstallOptions.rundir = rundir
+    end
+    opts.on('--logdir[=OPTIONAL]', 'Installation directory for log files', 'Default /var/log/puppetlabs/puppet') do |logdir|
+      InstallOptions.logdir = logdir
+    end
+    opts.on('--bindir[=OPTIONAL]', 'Installation directory for binaries', 'overrides RbConfig::CONFIG["bindir"]') do |bindir|
+      InstallOptions.bindir = bindir
+    end
+    opts.on('--localedir[=OPTIONAL]', 'Installation directory for locale information', 'Default /opt/puppetlabs/puppet/share/locale') do |localedir|
+      InstallOptions.localedir = localedir
+    end
+    opts.on('--ruby[=OPTIONAL]', 'Ruby interpreter to use with installation', 'overrides ruby used to call install.rb') do |ruby|
+      InstallOptions.ruby = ruby
+    end
+    opts.on('--sitelibdir[=OPTIONAL]', 'Installation directory for libraries', 'overrides RbConfig::CONFIG["sitelibdir"]') do |sitelibdir|
+      InstallOptions.sitelibdir = sitelibdir
+    end
+    opts.on('--mandir[=OPTIONAL]', 'Installation directory for man pages', 'overrides RbConfig::CONFIG["mandir"]') do |mandir|
+      InstallOptions.mandir = mandir
+    end
+    opts.on('--[no-]check-prereqs', 'Prevents validation of prerequisite libraries', 'Default on') do |prereq|
+      InstallOptions.check_prereqs = prereq
+    end
+    opts.on('--no-batch-files', 'Prevents installation of batch files for windows', 'Default off') do |batch_files|
+      InstallOptions.batch_files = false
+    end
+    opts.on('--quick', 'Performs a quick installation. Only the', 'installation is done.') do |quick|
+      InstallOptions.configs = true
+      warn "--quick is deprecated. Use --configs"
+    end
+    opts.separator("")
+    opts.on_tail('--help', "Shows this help text.") do
+      $stderr.puts opts
+      exit
+    end
+
+    opts.parse!
+  end
+
+  # Mac OS X 10.5 and higher declare bindir
+  # /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin
+  # which is not generally where people expect executables to be installed
+  # These settings are appropriate defaults for all OS X versions.
+  if RUBY_PLATFORM =~ /^universal-darwin[\d\.]+$/
+    RbConfig::CONFIG['bindir'] = "/usr/bin"
+  end
+
+  # Here we only set $osname if we have opted to check for prereqs.
+  # Otherwise facter won't be guaranteed to be present.
+  if InstallOptions.check_prereqs
+    check_prereqs
+    $osname = Facter.value('os.name')
+  end
+
+  if not InstallOptions.configdir.nil?
+    configdir = InstallOptions.configdir
+  elsif $osname == "windows"
+    configdir = File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "etc")
+  else
+    configdir = "/etc/puppetlabs/puppet"
+  end
+
+  if not InstallOptions.codedir.nil?
+    codedir = InstallOptions.codedir
+  elsif $osname == "windows"
+    codedir = File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "code")
+  else
+    codedir = "/etc/puppetlabs/code"
+  end
+
+  if not InstallOptions.vardir.nil?
+    vardir = InstallOptions.vardir
+  elsif $osname == "windows"
+    vardir = File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "cache")
+  else
+    vardir = "/opt/puppetlabs/puppet/cache"
+  end
+
+  if not InstallOptions.publicdir.nil?
+    publicdir = InstallOptions.publicdir
+  elsif $osname == "windows"
+    publicdir = File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "public")
+  else
+    publicdir = "/opt/puppetlabs/puppet/public"
+  end
+
+  if not InstallOptions.rundir.nil?
+    rundir = InstallOptions.rundir
+  elsif $osname == "windows"
+    rundir = File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "var", "run")
+  else
+    rundir = "/var/run/puppetlabs"
+  end
+
+  if not InstallOptions.logdir.nil?
+    logdir = InstallOptions.logdir
+  elsif $osname == "windows"
+    logdir = File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "var", "log")
+  else
+    logdir = "/var/log/puppetlabs/puppet"
+  end
+
+  if not InstallOptions.bindir.nil?
+    bindir = InstallOptions.bindir
+  else
+    bindir = RbConfig::CONFIG['bindir']
+  end
+
+  if not InstallOptions.localedir.nil?
+    localedir = InstallOptions.localedir
+  else
+    if $osname == "windows"
+      localedir = File.join(ENV['PROGRAMFILES'], "Puppet Labs", "Puppet", "puppet", "share", "locale")
+    else
+      localedir = "/opt/puppetlabs/puppet/share/locale"
+    end
+  end
+
+  if not InstallOptions.sitelibdir.nil?
+    sitelibdir = InstallOptions.sitelibdir
+  else
+    sitelibdir = RbConfig::CONFIG["sitelibdir"]
+    if sitelibdir.nil?
+      sitelibdir = $LOAD_PATH.find { |x| x =~ /site_ruby/ }
+      if sitelibdir.nil?
+        version = [RbConfig::CONFIG["MAJOR"], RbConfig::CONFIG["MINOR"]].join(".")
+        sitelibdir = File.join(RbConfig::CONFIG["libdir"], "ruby", version, "site_ruby")
+      elsif sitelibdir !~ Regexp.quote(version)
+        sitelibdir = File.join(sitelibdir, version)
+      end
+    end
+  end
+
+  if not InstallOptions.mandir.nil?
+    mandir = InstallOptions.mandir
+  else
+    mandir = RbConfig::CONFIG['mandir']
+  end
+
+  # This is the new way forward
+  if not InstallOptions.destdir.nil?
+    destdir = InstallOptions.destdir
+  else
+    destdir = ''
+  end
+
+  configdir = join(destdir, configdir)
+  codedir = join(destdir, codedir)
+  vardir = join(destdir, vardir)
+  publicdir = join(destdir, publicdir)
+  rundir = join(destdir, rundir)
+  logdir = join(destdir, logdir)
+  bindir = join(destdir, bindir)
+  localedir = join(destdir, localedir)
+  mandir = join(destdir, mandir)
+  sitelibdir = join(destdir, sitelibdir)
+
+  FileUtils.makedirs(configdir) if InstallOptions.configs
+  FileUtils.makedirs(codedir)
+  FileUtils.makedirs(bindir)
+  FileUtils.makedirs(mandir)
+  FileUtils.makedirs(sitelibdir)
+  FileUtils.makedirs(vardir)
+  FileUtils.makedirs(publicdir)
+  FileUtils.makedirs(rundir)
+  FileUtils.makedirs(logdir)
+  FileUtils.makedirs(localedir)
+
+  InstallOptions.site_dir = sitelibdir
+  InstallOptions.codedir = codedir
+  InstallOptions.config_dir = configdir
+  InstallOptions.bin_dir = bindir
+  InstallOptions.man_dir = mandir
+  InstallOptions.var_dir = vardir
+  InstallOptions.public_dir = publicdir
+  InstallOptions.run_dir = rundir
+  InstallOptions.log_dir = logdir
+  InstallOptions.locale_dir = localedir
+end
+
+##
+# Join two paths. On Windows, dir must be converted to a relative path,
+# by stripping the drive letter, but only if the basedir is not empty.
+#
+def join(basedir, dir)
+  return "#{basedir}#{dir[2..-1]}" if $osname == "windows" and basedir.length > 0 and dir.length > 2
+
+  "#{basedir}#{dir}"
+end
+
+##
+# Install file(s) from ./bin to RbConfig::CONFIG['bindir']. Patch it on the way
+# to insert a #! line; on a Unix install, the command is named as expected
+# (e.g., bin/rdoc becomes rdoc); the shebang line handles running it. Under
+# windows, we add an '.rb' extension and let file associations do their stuff.
+def install_binfile(from, op_file, target)
+  tmp_file = Tempfile.new('puppet-binfile')
+
+  if not InstallOptions.ruby.nil?
+    ruby = InstallOptions.ruby
+  else
+    ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  end
+
+  File.open(from) do |ip|
+    File.open(tmp_file.path, "w") do |op|
+      op.puts "#!#{ruby}" unless $osname == "windows"
+      contents = ip.readlines
+      contents.shift if contents[0] =~ /^#!/
+      op.write contents.join
+    end
+  end
+
+  if $osname == "windows" && InstallOptions.batch_files
+    installed_wrapper = false
+
+    unless File.extname(from) =~ /\.(cmd|bat)/
+      if File.exist?("#{from}.bat")
+        FileUtils.install("#{from}.bat", File.join(target, "#{op_file}.bat"), mode: 0755, preserve: true, verbose: true)
+        installed_wrapper = true
+      end
+
+      if File.exist?("#{from}.cmd")
+        FileUtils.install("#{from}.cmd", File.join(target, "#{op_file}.cmd"), mode: 0755, preserve: true, verbose: true)
+        installed_wrapper = true
+      end
+
+      if not installed_wrapper
+        tmp_file2 = Tempfile.new('puppet-wrapper')
+        cwv = <<-EOS
+@echo off
+SETLOCAL
+if exist "%~dp0environment.bat" (
+  call "%~dp0environment.bat" %0 %*
+) else (
+  SET "PATH=%~dp0;%PATH%"
+)
+ruby.exe -S -- puppet %*
+EOS
+        File.open(tmp_file2.path, "w") { |cw| cw.puts cwv }
+        FileUtils.install(tmp_file2.path, File.join(target, "#{op_file}.bat"), mode: 0755, preserve: true, verbose: true)
+
+        tmp_file2.unlink
+      end
+    end
+  end
+  FileUtils.install(tmp_file.path, File.join(target, op_file), mode: 0755, preserve: true, verbose: true)
+  tmp_file.unlink
+end
+
+# Change directory into the puppet root so we don't get the wrong files for install.
+FileUtils.cd File.dirname(__FILE__) do
+  # Set these values to what you want installed.
+  configs = glob(%w{conf/puppet.conf conf/hiera.yaml})
+  bins  = glob(%w{bin/*})
+  man   = glob(%w{man/man[0-9]/*})
+  libs  = glob(%w{lib/**/*})
+  locales = glob(%w{locales/**/*})
+
+  prepare_installation
+
+  if $osname == "windows"
+    windows_bins = glob(%w{ext/windows/*bat})
+  end
+
+  do_configs(configs, InstallOptions.config_dir) if InstallOptions.configs
+  do_bins(bins, InstallOptions.bin_dir)
+  do_bins(windows_bins, InstallOptions.bin_dir, 'ext/windows/') if $osname == "windows" && InstallOptions.batch_files
+  do_libs(libs)
+  do_locales(locales)
+  do_man(man) unless $osname == "windows"
+end

data/lib/hiera/puppet_function.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'hiera_puppet'
+
+# Provides the base class for the puppet functions hiera, hiera_array, hiera_hash, and hiera_include.
+# The actual function definitions will call init_dispatch and override the merge_type and post_lookup methods.
+#
+# @see hiera_array.rb, hiera_include.rb under lib/puppet/functions for sample usage
+#
+class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
+  def self.init_dispatch
+    dispatch :hiera_splat do
+      scope_param
+      param 'Tuple[String, Any, Any, 1, 3]', :args
+    end
+
+    dispatch :hiera_no_default do
+      scope_param
+      param 'String', :key
+    end
+
+    dispatch :hiera_with_default do
+      scope_param
+      param 'String', :key
+      param 'Any',   :default
+      optional_param 'Any', :override
+    end
+
+    dispatch :hiera_block1 do
+      scope_param
+      param 'String',              :key
+      block_param 'Callable[1,1]', :default_block
+    end
+
+    dispatch :hiera_block2 do
+      scope_param
+      param 'String',              :key
+      param 'Any',                 :override
+      block_param 'Callable[1,1]', :default_block
+    end
+  end
+
+  def hiera_splat(scope, args)
+    hiera(scope, *args)
+  end
+
+  def hiera_no_default(scope, key)
+    post_lookup(scope, key, lookup(scope, key, nil, false, nil))
+  end
+
+  def hiera_with_default(scope, key, default, override = nil)
+    post_lookup(scope, key, lookup(scope, key, default, true, override))
+  end
+
+  def hiera_block1(scope, key, &default_block)
+    post_lookup(scope, key, lookup(scope, key, nil, false, nil, &default_block))
+  end
+
+  def hiera_block2(scope, key, override, &default_block)
+    post_lookup(scope, key, lookup(scope, key, nil, false, override, &default_block))
+  end
+
+  def lookup(scope, key, default, has_default, override, &default_block)
+    unless Puppet[:strict] == :off
+      # TRANSLATORS 'lookup' is a puppet function and should not be translated
+      message = _("The function '%{class_name}' is deprecated in favor of using 'lookup'.") % { class_name: self.class.name }
+      message += ' ' + _("See https://puppet.com/docs/puppet/%{minor_version}/deprecated_language.html") %
+                       { minor_version: Puppet.minor_version }
+      Puppet.warn_once('deprecations', self.class.name, message)
+    end
+    lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {})
+    adapter = lookup_invocation.lookup_adapter
+    lookup_invocation.set_hiera_xxx_call
+    lookup_invocation.set_global_only unless adapter.global_only? || adapter.has_environment_data_provider?(lookup_invocation)
+    lookup_invocation.set_hiera_v3_location_overrides(override) unless override.nil? || override.is_a?(Array) && override.empty?
+    Puppet::Pops::Lookup.lookup(key, nil, default, has_default, merge_type, lookup_invocation, &default_block)
+  end
+
+  def merge_type
+    :first
+  end
+
+  def post_lookup(scope, key, result)
+    result
+  end
+end

data/lib/hiera/scope.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+class Hiera
+  class Scope
+    extend Forwardable
+
+    CALLING_CLASS = 'calling_class'
+    CALLING_CLASS_PATH = 'calling_class_path'
+    CALLING_MODULE = 'calling_module'
+    MODULE_NAME = 'module_name'
+
+    CALLING_KEYS = [CALLING_CLASS, CALLING_CLASS_PATH, CALLING_MODULE].freeze
+    EMPTY_STRING = ''
+
+    attr_reader :real
+
+    def initialize(real)
+      @real = real
+    end
+
+    def [](key)
+      case key
+      when CALLING_CLASS
+        ans = find_hostclass(@real)
+      when CALLING_CLASS_PATH
+        ans = find_hostclass(@real).gsub(/::/, '/')
+      when CALLING_MODULE
+        ans = safe_lookupvar(MODULE_NAME)
+      else
+        ans = safe_lookupvar(key)
+      end
+      ans == EMPTY_STRING ? nil : ans
+    end
+
+    # This method is used to handle the throw of :undefined_variable since when
+    # strict variables is not in effect, missing handling of the throw leads to
+    # a more expensive code path.
+    #
+    def safe_lookupvar(key)
+      reason = catch :undefined_variable do
+        return @real.lookupvar(key)
+      end
+
+      case Puppet[:strict]
+      when :off
+        # do nothing
+      when :warning
+        Puppet.warn_once(Puppet::Parser::Scope::UNDEFINED_VARIABLES_KIND, _("Variable: %{name}") % { name: key },
+                         _("Undefined variable '%{name}'; %{reason}") % { name: key, reason: reason })
+      when :error
+        raise ArgumentError, _("Undefined variable '%{name}'; %{reason}") % { name: key, reason: reason }
+      end
+      nil
+    end
+    private :safe_lookupvar
+
+    def exist?(key)
+      CALLING_KEYS.include?(key) || @real.exist?(key)
+    end
+
+    def include?(key)
+      CALLING_KEYS.include?(key) || @real.include?(key)
+    end
+
+    def catalog
+      @real.catalog
+    end
+
+    def resource
+      @real.resource
+    end
+
+    def compiler
+      @real.compiler
+    end
+
+    def find_hostclass(scope)
+      if scope.source and scope.source.type == :hostclass
+        scope.source.name.downcase
+      elsif scope.parent
+        find_hostclass(scope.parent)
+      else
+        nil
+      end
+    end
+    private :find_hostclass
+
+    # This is needed for type conversion to work
+    def_delegators :@real, :call_function
+  end
+end

data/lib/hiera_puppet.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+Puppet.features.hiera?
+require 'hiera/scope'
+require_relative 'puppet'
+
+module HieraPuppet
+  module_function
+
+  def lookup(key, default, scope, override, resolution_type)
+    scope = Hiera::Scope.new(scope)
+
+    answer = hiera.lookup(key, default, scope, override, resolution_type)
+
+    if answer.nil?
+      raise Puppet::ParseError, _("Could not find data item %{key} in any Hiera data file and no default supplied") % { key: key }
+    end
+
+    answer
+  end
+
+  def parse_args(args)
+    # Functions called from Puppet manifests like this:
+    #
+    #   hiera("foo", "bar")
+    #
+    # Are invoked internally after combining the positional arguments into a
+    # single array:
+    #
+    #   func = function_hiera
+    #   func(["foo", "bar"])
+    #
+    # Functions called from templates preserve the positional arguments:
+    #
+    #   scope.function_hiera("foo", "bar")
+    #
+    # Deal with Puppet's special calling mechanism here.
+    if args[0].is_a?(Array)
+      args = args[0]
+    end
+
+    if args.empty?
+      raise Puppet::ParseError, _("Please supply a parameter to perform a Hiera lookup")
+    end
+
+    key      = args[0]
+    default  = args[1]
+    override = args[2]
+
+    [key, default, override]
+  end
+
+  def hiera
+    @hiera ||= Hiera.new(:config => hiera_config)
+  end
+
+  def hiera_config
+    config = {}
+
+    config_file = hiera_config_file
+    if config_file
+      config = Hiera::Config.load(config_file)
+    end
+
+    config[:logger] = 'puppet'
+    config
+  end
+
+  def hiera_config_file
+    hiera_config = Puppet.settings[:hiera_config]
+    if Puppet::FileSystem.exist?(hiera_config)
+      hiera_config
+    else
+      Puppet.warning _("Config file %{hiera_config} not found, using Hiera defaults") % { hiera_config: hiera_config }
+      nil
+    end
+  end
+end