openvox 8.19.0

data/lib/puppet/context.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative '../puppet/thread_local'
+
+# Puppet::Context is a system for tracking services and contextual information
+# that puppet needs to be able to run. Values are "bound" in a context when it is created
+# and cannot be changed; however a child context can be created, using
+# {#override}, that provides a different value.
+#
+# When binding a {Proc}, the proc is called when the value is looked up, and the result
+# is memoized for subsequent lookups. This provides a lazy mechanism that can be used to
+# delay expensive production of values until they are needed.
+#
+# @api private
+class Puppet::Context
+  require_relative 'context/trusted_information'
+
+  class UndefinedBindingError < Puppet::Error; end
+  class StackUnderflow < Puppet::Error; end
+
+  class UnknownRollbackMarkError < Puppet::Error; end
+  class DuplicateRollbackMarkError < Puppet::Error; end
+
+  # @api private
+  def initialize(initial_bindings)
+    @stack = Puppet::ThreadLocal.new(EmptyStack.new.push(initial_bindings))
+
+    # By initializing @rollbacks to nil and creating a hash lazily when #mark or
+    # #rollback are called we ensure that the hashes are never shared between
+    # threads and it's safe to mutate them
+    @rollbacks = Puppet::ThreadLocal.new(nil)
+  end
+
+  # @api private
+  def push(overrides, description = '')
+    @stack.value = @stack.value.push(overrides, description)
+  end
+
+  # Push a context and make this global across threads
+  # Do not use in a context where multiple threads may already exist
+  #
+  # @api private
+  def unsafe_push_global(overrides, description = '')
+    @stack = Puppet::ThreadLocal.new(
+      @stack.value.push(overrides, description)
+    )
+  end
+
+  # @api private
+  def pop
+    @stack.value = @stack.value.pop
+  end
+
+  # @api private
+  def lookup(name, &block)
+    @stack.value.lookup(name, &block)
+  end
+
+  # @api private
+  def override(bindings, description = '', &block)
+    saved_point = @stack.value
+    push(bindings, description)
+
+    yield
+  ensure
+    @stack.value = saved_point
+  end
+
+  # Mark a place on the context stack to later return to with {rollback}.
+  #
+  # @param name [Object] The identifier for the mark
+  #
+  # @api private
+  def mark(name)
+    @rollbacks.value ||= {}
+    if @rollbacks.value[name].nil?
+      @rollbacks.value[name] = @stack.value
+    else
+      raise DuplicateRollbackMarkError, _("Mark for '%{name}' already exists") % { name: name }
+    end
+  end
+
+  # Roll back to a mark set by {mark}.
+  #
+  # Rollbacks can only reach a mark accessible via {pop}. If the mark is not on
+  # the current context stack the behavior of rollback is undefined.
+  #
+  # @param name [Object] The identifier for the mark
+  #
+  # @api private
+  def rollback(name)
+    @rollbacks.value ||= {}
+    if @rollbacks.value[name].nil?
+      raise UnknownRollbackMarkError, _("Unknown mark '%{name}'") % { name: name }
+    end
+
+    @stack.value = @rollbacks.value.delete(name)
+  end
+
+  # Base case for Puppet::Context::Stack.
+  #
+  # @api private
+  class EmptyStack
+    # Lookup a binding. Since there are none in EmptyStack, this always raises
+    # an exception unless a block is passed, in which case the block is called
+    # and its return value is used.
+    #
+    # @api private
+    def lookup(name, &block)
+      if block
+        block.call
+      else
+        raise UndefinedBindingError, _("Unable to lookup '%{name}'") % { name: name }
+      end
+    end
+
+    # Base case of #pop always raises an error since this is the bottom
+    #
+    # @api private
+    def pop
+      raise(StackUnderflow,
+            _('Attempted to pop, but already at root of the context stack.'))
+    end
+
+    # Push bindings onto the stack by creating a new Stack object with `self` as
+    # the parent
+    #
+    # @api private
+    def push(overrides, description = '')
+      Puppet::Context::Stack.new(self, overrides, description)
+    end
+
+    # Return the bindings table, which is always empty here
+    #
+    # @api private
+    def bindings
+      {}
+    end
+  end
+
+  # Internal implementation of the bindings stack used by Puppet::Context. An
+  # instance of Puppet::Context::Stack represents one level of bindings. It
+  # caches a merged copy of all the bindings in the stack up to this point.
+  # Each element of the stack is immutable, allowing the base to be shared
+  # between threads.
+  #
+  # @api private
+  class Stack
+    attr_reader :bindings
+
+    def initialize(parent, bindings, description = '')
+      @parent = parent
+      @bindings = parent.bindings.merge(bindings || {})
+      @description = description
+    end
+
+    # Lookup a binding in the current stack. Return the value if it is present.
+    # If the value is a stored Proc, evaluate, cache, and return the result. If
+    # no binding is found and a block is passed evaluate it and return the
+    # result. Otherwise an exception is raised.
+    #
+    # @api private
+    def lookup(name, &block)
+      if @bindings.include?(name)
+        value = @bindings[name]
+        value.is_a?(Proc) ? (@bindings[name] = value.call) : value
+      elsif block
+        block.call
+      else
+        raise UndefinedBindingError,
+              _("Unable to lookup '%{name}'") % { name: name }
+      end
+    end
+
+    # Pop one level off the stack by returning the parent object.
+    #
+    # @api private
+    def pop
+      @parent
+    end
+
+    # Push bindings onto the stack by creating a new Stack object with `self` as
+    # the parent
+    #
+    # @api private
+    def push(overrides, description = '')
+      Puppet::Context::Stack.new(self, overrides, description)
+    end
+  end
+end

data/lib/puppet/daemon.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative '../puppet/application'
+require_relative '../puppet/scheduler'
+
+# Run periodic actions in a daemonized process.
+#
+# A Daemon has 2 parts:
+#   * config reparse
+#   * an agent that responds to #run
+#
+# The config reparse will occur periodically based on Settings. The agent
+# is run periodically and a time interval based on Settings. The config
+# reparse will update this time interval when needed.
+#
+# The Daemon is also responsible for signal handling, starting, stopping,
+# running the agent on demand, and reloading the entire process. It ensures
+# that only one Daemon is running by using a lockfile.
+#
+# @api private
+class Puppet::Daemon
+  SIGNAL_CHECK_INTERVAL = 5
+
+  attr_accessor :argv
+  attr_reader :signals, :agent
+
+  def initialize(agent, pidfile, scheduler = Puppet::Scheduler::Scheduler.new())
+    raise Puppet::DevError, _("Daemons must have an agent") unless agent
+
+    @scheduler = scheduler
+    @pidfile = pidfile
+    @agent = agent
+    @signals = []
+  end
+
+  def daemonname
+    Puppet.run_mode.name
+  end
+
+  # Put the daemon into the background.
+  def daemonize
+    pid = fork
+    if pid
+      Process.detach(pid)
+      exit(0)
+    end
+
+    create_pidfile
+
+    # Get rid of console logging
+    Puppet::Util::Log.close(:console)
+
+    Process.setsid
+    Dir.chdir("/")
+
+    close_streams
+  end
+
+  # Close stdin/stdout/stderr so that we can finish our transition into 'daemon' mode.
+  # @return nil
+  def self.close_streams
+    Puppet.debug("Closing streams for daemon mode")
+    begin
+      $stdin.reopen "/dev/null"
+      $stdout.reopen "/dev/null", "a"
+      $stderr.reopen $stdout
+      Puppet::Util::Log.reopen
+      Puppet.debug("Finished closing streams for daemon mode")
+    rescue => detail
+      Puppet.err "Could not start #{Puppet.run_mode.name}: #{detail}"
+      Puppet::Util.replace_file("/tmp/daemonout", 0o644) do |f|
+        f.puts "Could not start #{Puppet.run_mode.name}: #{detail}"
+      end
+      exit(12)
+    end
+  end
+
+  # Convenience signature for calling Puppet::Daemon.close_streams
+  def close_streams
+    Puppet::Daemon.close_streams
+  end
+
+  def reexec
+    raise Puppet::DevError, _("Cannot reexec unless ARGV arguments are set") unless argv
+
+    command = $PROGRAM_NAME + " " + argv.join(" ")
+    Puppet.notice "Restarting with '#{command}'"
+    stop(:exit => false)
+    exec(command)
+  end
+
+  def reload
+    agent.run({ :splay => false })
+  rescue Puppet::LockError
+    Puppet.notice "Not triggering already-running agent"
+  end
+
+  def restart
+    Puppet::Application.restart!
+    reexec
+  end
+
+  def reopen_logs
+    Puppet::Util::Log.reopen
+  end
+
+  # Trap a couple of the main signals.  This should probably be handled
+  # in a way that anyone else can register callbacks for traps, but, eh.
+  def set_signal_traps
+    [:INT, :TERM].each do |signal|
+      Signal.trap(signal) do
+        Puppet.notice "Caught #{signal}; exiting"
+        stop
+      end
+    end
+
+    # extended signals not supported under windows
+    unless Puppet::Util::Platform.windows?
+      signals = { :HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }
+      signals.each do |signal, method|
+        Signal.trap(signal) do
+          Puppet.notice "Caught #{signal}; storing #{method}"
+          @signals << method
+        end
+      end
+    end
+  end
+
+  # Stop everything
+  def stop(args = { :exit => true })
+    Puppet::Application.stop!
+
+    remove_pidfile
+
+    Puppet::Util::Log.close_all
+
+    exit if args[:exit]
+  end
+
+  def start
+    create_pidfile
+    run_event_loop
+  end
+
+  private
+
+  # Create a pidfile for our daemon, so we can be stopped and others
+  # don't try to start.
+  def create_pidfile
+    raise "Could not create PID file: #{@pidfile.file_path}" unless @pidfile.lock
+  end
+
+  # Remove the pid file for our daemon.
+  def remove_pidfile
+    @pidfile.unlock
+  end
+
+  # Loop forever running events - or, at least, until we exit.
+  def run_event_loop
+    splaylimit = Puppet[:splay] ? Puppet[:splaylimit] : 0
+
+    agent_run = Puppet::Scheduler.create_job(Puppet[:runinterval], true, splaylimit) do |job|
+      if job.splay != 0
+        Puppet.info "Running agent every #{job.run_interval} seconds with splay #{job.splay} of #{job.splay_limit} seconds"
+      else
+        Puppet.info "Running agent every #{job.run_interval} seconds"
+      end
+
+      # Splay for the daemon is handled in the scheduler
+      agent.run(:splay => false)
+    end
+
+    reparse_run = Puppet::Scheduler.create_job(Puppet[:filetimeout]) do
+      Puppet.settings.reparse_config_files
+      agent_run.run_interval = Puppet[:runinterval]
+      # Puppet[:splaylimit] defaults to Puppet[:runinterval] so if runinterval
+      # changes, but splaylimit doesn't, we'll still recalculate splay
+      agent_run.splay_limit = Puppet[:splay] ? Puppet[:splaylimit] : 0
+      if Puppet[:filetimeout] == 0
+        reparse_run.disable
+      else
+        reparse_run.run_interval = Puppet[:filetimeout]
+      end
+    end
+
+    signal_loop = Puppet::Scheduler.create_job(SIGNAL_CHECK_INTERVAL) do
+      while method = @signals.shift # rubocop:disable Lint/AssignmentInCondition
+        Puppet.notice "Processing #{method}"
+        send(method)
+      end
+    end
+
+    reparse_run.disable if Puppet[:filetimeout] == 0
+
+    # these are added in a different order than they are defined
+    @scheduler.run_loop([reparse_run, agent_run, signal_loop])
+  end
+end

data/lib/puppet/data_binding.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative '../puppet/indirector'
+
+# A class for managing data lookups
+class Puppet::DataBinding
+  # Set up indirection, so that data can be looked for in the compiler
+  extend Puppet::Indirector
+
+  indirects(:data_binding, :terminus_setting => :data_binding_terminus,
+                           :doc => "Where to find external data bindings.")
+
+  class LookupError < Puppet::PreformattedError; end
+
+  class RecursiveLookupError < Puppet::DataBinding::LookupError; end
+end

data/lib/puppet/datatypes/error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Puppet::DataTypes.create_type('Error') do
+  interface <<-PUPPET
+    type_parameters => {
+      kind => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]],
+      issue_code => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]]
+    },
+    attributes => {
+      msg => String[1],
+      kind => { type => Optional[String[1]], value => undef },
+      details => { type => Optional[Hash[String[1],Data]], value => undef },
+      issue_code => { type => Optional[String[1]], value => undef },
+    },
+    functions => {
+      message => Callable[[], String[1]]
+    }
+  PUPPET
+
+  require_relative '../../puppet/datatypes/impl/error'
+
+  implementation_class Puppet::DataTypes::Error
+end

data/lib/puppet/datatypes/impl/error.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Puppet::DataTypes::Error
+  attr_reader :msg, :kind, :issue_code, :details
+  alias message msg
+
+  def self.from_asserted_hash(hash)
+    new(hash['msg'], hash['kind'], hash['details'], hash['issue_code'])
+  end
+
+  def _pcore_init_hash
+    result = { 'msg' => @msg }
+    result['kind'] = @kind unless @kind.nil?
+    result['details'] = @details unless @details.nil?
+    result['issue_code'] = @issue_code unless @issue_code.nil?
+    result
+  end
+
+  def initialize(msg, kind = nil, details = nil, issue_code = nil)
+    @msg = msg
+    @kind = kind
+    @details = details
+    @issue_code = issue_code
+  end
+
+  def eql?(o)
+    self.class.equal?(o.class) &&
+      @msg == o.msg &&
+      @kind == o.kind &&
+      @issue_code == o.issue_code &&
+      @details == o.details
+  end
+  alias == eql?
+
+  def hash
+    @msg.hash ^ @kind.hash ^ @issue_code.hash
+  end
+
+  def to_s
+    Puppet::Pops::Types::StringConverter.singleton.convert(self)
+  end
+end

data/lib/puppet/datatypes.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+# Data types in the Puppet Language can have implementations written in Ruby
+# and distributed in puppet modules. A data type can be declared together with
+# its implementation by creating a file in 'lib/puppet/functions/<modulename>'.
+# The name of the file must be the downcased name of the data type followed by
+# the extension '.rb'.
+#
+# A data type is created by calling {Puppet::DataTypes.create_type(<type name>)}
+# and passing it a block that defines the data type interface and implementation.
+#
+# Data types are namespaced inside the modules that contains them. The name of the
+# data type is prefixed with the name of the module. As with all type names, each
+# segment of the name must start with an uppercase letter.
+#
+# @example A simple data type
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String
+#       }
+#     PUPPET
+#   end
+#
+# The above example does not declare an implementation which makes it equivalent
+# to adding the following contents in a file named 'user.pp' under the 'types' directory
+# of the module root.
+#
+#   type Auth::User = Object[
+#     attributes => {
+#       name => String,
+#       email => String
+#     }]
+#
+# Both declarations are valid and will be found by the module loader.
+#
+# Structure of a data type
+# ---
+#
+# A Data Type consists of an interface and an implementation. Unless a registered implementation
+# is found, the type system will automatically generate one. An  automatically generated
+# implementation is all that is needed when the interface fully  defines the behaviour (for
+# example in the common case when the data type has no other behaviour than having attributes).
+#
+# When the automatically generated implementation is not sufficient, one must be implemented and
+# registered. The implementation can either be done next to the interface definition by passing
+# a block to `implementation`, or map to an existing implementation class by passing the class
+# as an argument to `implementation_class`. An implementation class does not have to be special
+# in other respects than that it must implemented the type's interface. This makes it possible
+# to use existing Ruby data types as data types in the puppet language.
+#
+# Note that when using `implementation_class` there can only be one such implementation across
+# all environments managed by one puppet server and you must handle and install these
+# implementations as if they are part of the puppet platform. In contrast; the type
+# implementations that are done inside of the type's definition are safe to use in different
+# versions in different environments (given that they do not need additional external logic to
+# be loaded).
+#
+# When using an `implementation_class` it is sometimes desirable to load this class from the
+# 'lib' directory of the module. The method `load_file` is provided to facilitate such a load.
+# The `load_file` will use the `Puppet::Util::Autoload` to search for the given file in the 'lib'
+# directory of the current environment and the 'lib' directory in each included module.
+#
+# @example Adding implementation on top of the generated type using `implementation`
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String,
+#         year_of_birth => Integer,
+#         age => { type => Integer, kind => derived }
+#       }
+#       PUPPET
+#
+#     implementation do
+#       def age
+#         DateTime.now.year - @year_of_birth
+#       end
+#     end
+#   end
+#
+# @example Appointing an already existing implementation class
+#
+# Assumes the following class is declared under 'lib/puppetx/auth' in the module:
+#
+#   class PuppetX::Auth::User
+#     attr_reader :name, :year_of_birth
+#     def initialize(name, year_of_birth)
+#       @name = name
+#       @year_of_birth = year_of_birth
+#     end
+#
+#     def age
+#       DateTime.now.year - @year_of_birth
+#     end
+#
+#     def send_text(sender, text)
+#       sender.send_text_from(@name, text)
+#     end
+#   end
+#
+# Then the type declaration can look like this:
+#
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String,
+#         year_of_birth => Integer,
+#         age => { type => Integer, kind => derived }
+#       },
+#       functions => {
+#         send_text => Callable[Sender, String[1]]
+#       }
+#       PUPPET
+#
+#     # This load_file is optional and only needed in case
+#     # the implementation is not loaded by other means.
+#     load_file 'puppetx/auth/user'
+#
+#     implementation_class PuppetX::Auth::User
+#   end
+#
+module Puppet::DataTypes
+  def self.create_type(type_name, &block)
+    # Ruby < 2.1.0 does not have method on Binding, can only do eval
+    # and it will fail unless protected with an if defined? if the local
+    # variable does not exist in the block's binder.
+    #
+
+    loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
+    create_loaded_type(type_name, loader, &block)
+  rescue StandardError => e
+    raise ArgumentError, _("Data Type Load Error for type '%{type_name}': %{message}") % { type_name: type_name, message: e.message }
+  end
+
+  def self.create_loaded_type(type_name, loader, &block)
+    builder = TypeBuilder.new(type_name.to_s)
+    api = TypeBuilderAPI.new(builder).freeze
+    api.instance_eval(&block)
+    builder.create_type(loader)
+  end
+
+  # @api private
+  class TypeBuilder
+    attr_accessor :interface, :implementation, :implementation_class
+
+    def initialize(type_name)
+      @type_name = type_name
+      @implementation = nil
+      @implementation_class = nil
+    end
+
+    def create_type(loader)
+      raise ArgumentError, _('a data type must have an interface') unless @interface.is_a?(String)
+
+      created_type = Puppet::Pops::Types::PObjectType.new(
+        @type_name,
+        Puppet::Pops::Parser::EvaluatingParser.new.parse_string("{ #{@interface} }").body
+      )
+
+      if !@implementation_class.nil?
+        if @implementation_class < Puppet::Pops::Types::PuppetObject
+          @implementation_class.instance_eval do
+            include Puppet::Pops::Types::PuppetObject
+            @_pcore_type = created_type
+
+            def self._pcore_type
+              @_pcore_type
+            end
+          end
+        else
+          Puppet::Pops::Loaders.implementation_registry.register_implementation(created_type, @implementation_class)
+        end
+        created_type.implementation_class = @implementation_class
+      elsif !@implementation.nil?
+        created_type.implementation_override = @implementation
+      end
+      created_type
+    end
+
+    def has_implementation?
+      !(@implementation_class.nil? && @implementation.nil?)
+    end
+  end
+
+  # The TypeBuilderAPI class exposes only those methods that the builder API provides
+  # @api public
+  class TypeBuilderAPI
+    # @api private
+    def initialize(type_builder)
+      @type_builder = type_builder
+    end
+
+    def interface(type_string)
+      raise ArgumentError, _('a data type can only have one interface') unless @type_builder.interface.nil?
+
+      @type_builder.interface = type_string
+    end
+
+    def implementation(&block)
+      raise ArgumentError, _('a data type can only have one implementation') if @type_builder.has_implementation?
+
+      @type_builder.implementation = block
+    end
+
+    def implementation_class(ruby_class)
+      raise ArgumentError, _('a data type can only have one implementation') if @type_builder.has_implementation?
+
+      @type_builder.implementation_class = ruby_class
+    end
+
+    def load_file(file_name)
+      Puppet::Util::Autoload.load_file(file_name, Puppet.lookup(:current_environment))
+    end
+  end
+end