puppet 3.8.7 → 4.0.0

data/lib/puppet/util/instrumentation/listeners/performance.rb

@@ -1,24 +0,0 @@
-Puppet::Util::Instrumentation.new_listener(:performance) do
-
-  attr_reader :samples
-
-  def initialize
-    @samples = {}
-  end
-
-  def notify(label, event, data)
-    return if event == :start
-
-    duration = data[:finished] - data[:started]
-    @samples[label] ||= { :count => 0, :max => 0, :min => nil, :sum => 0, :average => 0 }
-    @samples[label][:count] += 1
-    @samples[label][:sum] += duration
-    @samples[label][:max] = [ @samples[label][:max], duration ].max
-    @samples[label][:min] = [ @samples[label][:min], duration ].reject { |val| val.nil? }.min
-    @samples[label][:average] = @samples[label][:sum] / @samples[label][:count]
-  end
-
-  def data
-    @samples.dup
-  end
-end

data/lib/puppet/util/instrumentation.rb

@@ -1,152 +0,0 @@
-require 'puppet'
-require 'puppet/util/classgen'
-require 'puppet/util/instance_loader'
-
-class Puppet::Util::Instrumentation
-  extend Puppet::Util::ClassGen
-  extend Puppet::Util::InstanceLoader
-
-  # we're using a ruby lazy autoloader to prevent a loop when requiring listeners
-  # since this class sets up an indirection which is also used in Puppet::Indirector::Indirection
-  # which is used to setup indirections...
-  autoload :Listener, 'puppet/util/instrumentation/listener'
-  autoload :Data, 'puppet/util/instrumentation/data'
-
-  # Set up autoloading and retrieving of instrumentation listeners.
-  instance_load :listener, 'puppet/util/instrumentation/listeners'
-
-  class << self
-    attr_accessor :listeners, :listeners_of
-  end
-
-  # instrumentation layer
-
-  # Triggers an instrumentation
-  #
-  # Call this method around the instrumentation point
-  #   Puppet::Util::Instrumentation.instrument(:my_long_computation) do
-  #     ... a long computation
-  #   end
-  #
-  # This will send an event to all the listeners of "my_long_computation".
-  # Note: this method uses ruby yield directive to call the instrumented code.
-  # It is usually way slower than calling start and stop directly around the instrumented code.
-  # For high traffic code path, it is thus advisable to not use this method.
-  def self.instrument(label, data = {})
-    id = self.start(label, data)
-    yield
-  ensure
-    self.stop(label, id, data)
-  end
-
-  # Triggers a "start" instrumentation event
-  #
-  # Important note:
-  #  For proper use, the data hash instance used for start should also
-  #  be used when calling stop. The idea is to use the current scope
-  #  where start is called to retain a reference to 'data' so that it is possible
-  #  to send it back to stop.
-  #  This way listeners can match start and stop events more easily.
-  def self.start(label, data)
-    data[:started] = Time.now
-    publish(label, :start, data)
-    data[:id] = next_id
-  end
-
-  # Triggers a "stop" instrumentation event
-  def self.stop(label, id, data)
-    data[:finished] = Time.now
-    publish(label, :stop, data)
-  end
-
-  def self.publish(label, event, data)
-    each_listener(label) do |k,l|
-      l.notify(label, event, data)
-    end
-  end
-
-  def self.listeners
-    @listeners.values
-  end
-
-  def self.each_listener(label)
-    @listeners_of[label] ||= @listeners.select do |k,l|
-      l.listen_to?(label)
-    end.each do |l|
-      yield l
-    end
-  end
-
-  # Adds a new listener
-  #
-  # Usage:
-  #   Puppet::Util::Instrumentation.new_listener(:my_instrumentation, pattern) do
-  #
-  #     def notify(label, data)
-  #       ... do something for data...
-  #     end
-  #   end
-  #
-  # It is possible to use a "pattern". The listener will be notified only
-  # if the pattern match the label of the event.
-  # The pattern can be a symbol, a string or a regex.
-  # If no pattern is provided, then the listener will be called for every events
-  def self.new_listener(name, options = {}, &block)
-    Puppet.debug "new listener called #{name}"
-    name = name.intern
-    listener = genclass(name, :hash => instance_hash(:listener), :block => block)
-    listener.send(:define_method, :name) do
-      name
-    end
-    subscribe(listener.new, options[:label_pattern], options[:event])
-  end
-
-  def self.subscribe(listener, label_pattern, event)
-    raise "Listener #{listener.name} is already subscribed" if @listeners.include?(listener.name)
-    Puppet.debug "registering instrumentation listener #{listener.name}"
-    @listeners[listener.name] = Listener.new(listener, label_pattern, event)
-    listener.subscribed if listener.respond_to?(:subscribed)
-    rehash
-  end
-
-  def self.unsubscribe(listener)
-    Puppet.warning("#{listener.name} hasn't been registered but asked to be unregistered") unless @listeners.include?(listener.name)
-    Puppet.info "unregistering instrumentation listener #{listener.name}"
-    @listeners.delete(listener.name)
-    listener.unsubscribed if listener.respond_to?(:unsubscribed)
-    rehash
-  end
-
-  def self.init
-    # let's init our probe indirection
-    require 'puppet/util/instrumentation/indirection_probe'
-    @listeners ||= {}
-    @listeners_of ||= {}
-    instance_loader(:listener).loadall
-  end
-
-  def self.clear
-    @listeners = {}
-    @listeners_of = {}
-    @id = 0
-  end
-
-  def self.[](key)
-    @listeners[key.intern]
-  end
-
-  def self.[]=(key, value)
-    @listeners[key.intern] = value
-    rehash
-  end
-
-  private
-
-  def self.rehash
-    @listeners_of = {}
-  end
-
-  def self.next_id
-    @id = (@id || 0) + 1
-  end
-end

data/lib/puppet/util/log/rate_limited_logger.rb

@@ -1,40 +0,0 @@
-require 'puppet/util/logging'
-
-# Logging utility class that limits the frequency of identical log messages
-class Puppet::Util::Log::RateLimitedLogger
-  include Puppet::Util::Logging
-
-  def initialize(interval)
-    raise ArgumentError, "Logging rate-limit interval must be an integer" unless interval.is_a?(Integer)
-    @interval = interval
-    @log_record = {}
-  end
-
-  # Override the logging entry point to rate-limit it
-  def send_log(level, message)
-    Puppet::Util::Log.create({:level => level, :message => message}) if should_log?(level, message)
-  end
-
-  private
-
-  def should_log?(level, message)
-    # Initialize separate records for different levels, and only when needed
-    record = (@log_record[level] ||= {})
-    last_log = record[message]
-
-    # Skip logging if the time interval since the last logging hasn't elapsed yet
-    return false if last_log and within_interval?(last_log)
-
-    # Purge stale entries; do this after the interval check to reduce passes through the cache
-    record.delete_if { |key, time| !within_interval?(time) }
-
-    # Reset the beginning of the interval to the current time
-    record[message] = Time.now
-
-    true
-  end
-
-  def within_interval?(time)
-    time + @interval > Time.now
-  end
-end

data/lib/puppet/util/monkey_patches/lines.rb

@@ -1,13 +0,0 @@
-require 'puppet/util/monkey_patches'
-require 'enumerator'
-
-module Puppet::Util::MonkeyPatches::Lines
-  def lines(separator = $/)
-    if block_given?
-      self.each_line(separator) {|line| yield line }
-      return self
-    else
-      return enum_for(:each_line, separator)
-    end
-  end
-end

data/lib/puppet/util/plugins.rb

@@ -1,82 +0,0 @@
-#
-# This system manages an extensible set of metadata about plugins which it
-#   collects by searching for files named "plugin_init.rb" in a series of
-#   directories.  Initially, these are simply the $LOAD_PATH.
-#
-# The contents of each file found is executed in the context of a Puppet::Plugins
-#    object (and thus scoped).  An example file might contain:
-#
-# -------------------------------------------------------
-#      @name = "Greet the CA"
-#
-#      @description = %q{
-#        This plugin causes a friendly greeting to print out on a master
-#        that is operating as the CA, after it has been set up but before
-#        it does anything.
-#      }
-#
-#      def after_application_setup(options)
-#        if options[:application_object].is_a?(Puppet::Application::Master) && Puppet::SSL::CertificateAuthority.ca?
-#          puts "Hey, this is the CA!"
-#        end
-#      end
-# -------------------------------------------------------
-#
-# Note that the instance variables are local to this Puppet::Plugin (and so may be used
-#   for maintaining state, etc.) but the plugin system does not provide any thread safety
-#   assurances, so they may not be adequate for some complex use cases.
-
-
-module Puppet
-  class Plugins
-    Paths  = [] # Where we might find plugin initialization code
-    Loaded = [] # Code we have found (one-to-one with paths once searched)
-    #
-    # Return all the Puppet::Plugins we know about, searching any new paths
-    #
-    def self.known
-      Paths[Loaded.length...Paths.length].each { |path|
-        file = File.join(path,'plugin_init.rb')
-        Loaded << (Puppet::FileSystem.exist?(file) && new(file))
-      }
-      Loaded.compact
-    end
-    #
-    # Add more places to look for plugins without adding duplicates or changing the
-    #   order of ones we've already found.
-    #
-    def self.look_in(*paths)
-      Paths.replace Paths | paths.flatten.collect { |path| File.expand_path(path) }
-    end
-    #
-    # Initially just look in $LOAD_PATH
-    #
-    look_in $LOAD_PATH
-    #
-    # Calling methods (hooks) on the class calls the method of the same name on
-    #   all plugins that use that hook, passing in the same arguments to each
-    #   and returning an array containing the results returned by each plugin as
-    #   an array of [plugin_name,result] pairs.
-    #
-    def self.method_missing(hook,*args,&block)
-      known.
-        select  { |p| p.respond_to? hook }.
-        collect { |p| [p.name,p.send(hook,*args,&block)] }
-    end
-    #
-    #
-    #
-    attr_reader :path,:name
-    def initialize(path)
-      @name = @path = path
-      class << self
-        private
-        def define_hooks
-          eval File.read(path),nil,path,1
-        end
-      end
-      define_hooks
-    end
-  end
-end
-

data/lib/puppet/util/pson.rb

@@ -1,13 +0,0 @@
-# A simple module to provide consistency between how we use PSON and how
-# ruby expects it to be used.  Basically, we don't want to require
-# that the sender specify a class.
-#  Ruby wants everyone to provide a 'type' field, and the PSON support
-# requires such a field to track the class down.  Because we use our URL to
-# figure out what class we're working on, we don't need that, and we don't want
-# our consumers and producers to need to know anything about our internals.
-module Puppet::Util::Pson
-  def pson_create(pson)
-    raise ArgumentError, "No data provided in pson data" unless pson['data']
-    from_data_hash(pson['data'])
-  end
-end

data/lib/puppet/util/queue/stomp.rb

@@ -1,60 +0,0 @@
-require 'puppet/util/queue'
-require 'stomp'
-require 'uri'
-
-# Implements the Ruby Stomp client as a queue type within the
-# Puppet::Indirector::Queue::Client registry, for use with the <tt>:queue</tt>
-# indirection terminus type.
-#
-# Looks to <tt>Puppet[:queue_source]</tt> for the sole argument to the
-# underlying Stomp::Client constructor; consequently, for this client to work,
-# <tt>Puppet[:queue_source]</tt> must use the Stomp::Client URL-like syntax
-# for identifying the Stomp message broker: <em>login:pass@host.port</em>
-class Puppet::Util::Queue::Stomp
-  attr_accessor :stomp_client
-
-  def initialize
-    begin
-      uri = URI.parse(Puppet[:queue_source])
-    rescue => detail
-      raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is invalid: #{detail}", detail.backtrace
-    end
-    unless uri.scheme == "stomp"
-      raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is not a Stomp URL: #{detail}"
-    end
-
-    begin
-      self.stomp_client = Stomp::Client.new(uri.user, uri.password, uri.host, uri.port, true)
-    rescue => detail
-      raise ArgumentError, "Could not create Stomp client instance with queue source #{Puppet[:queue_source]}: got internal Stomp client error #{detail}", detail.backtrace
-    end
-
-    # Identify the supported method for sending messages.
-    @method =
-      case
-      when stomp_client.respond_to?(:publish)
-        :publish
-      when stomp_client.respond_to?(:send)
-        :send
-      else
-        raise ArgumentError, "STOMP client does not respond to either publish or send"
-      end
-  end
-
-  def publish_message(target, msg)
-    stomp_client.__send__(@method, stompify_target(target), msg, :persistent => true)
-  end
-
-  def subscribe(target)
-    stomp_client.subscribe(stompify_target(target), :ack => :client) do |stomp_message|
-      yield(stomp_message.body)
-      stomp_client.acknowledge(stomp_message)
-    end
-  end
-
-  def stompify_target(target)
-    '/queue/' + target.to_s
-  end
-
-  Puppet::Util::Queue.register_queue_type(self, :stomp)
-end

data/lib/puppet/util/queue.rb

@@ -1,96 +0,0 @@
-
-require 'puppet/indirector'
-require 'puppet/util/instance_loader'
-
-# Implements a message queue client type plugin registry for use by the indirector facility.
-# Client modules for speaking a particular protocol (e.g. Stomp::Client for Stomp message
-# brokers, Memcached for Starling and Sparrow, etc.) register themselves with this module.
-#
-# Client classes are expected to live under the Puppet::Util::Queue namespace and corresponding
-# directory; the attempted use of a client via its typename (see below) will cause Puppet::Util::Queue
-# to attempt to load the corresponding plugin if it is not yet loaded.  The client class registers itself
-# with Puppet::Util::Queue and should use the same type name as the autloader expects for the plugin file.
-#   class Puppet::Util::Queue::SpecialMagicalClient < Messaging::SpecialMagic
-#       ...
-#       Puppet::Util::Queue.register_queue_type_class(self)
-#   end
-#
-# This module reduces the rightmost segment of the class name into a pretty symbol that will
-# serve as the queuing client's name.  Which means that the "SpecialMagicalClient" above will
-# be named <em>:special_magical_client</em> within the registry.
-#
-# Another class/module may mix-in this module, and may then make use of the registered clients.
-#   class Queue::Fue
-#       # mix it in at the class object level rather than instance level
-#       extend ::Puppet::Util::Queue
-#   end
-#
-# Queue::Fue instances can get a message queue client through the registry through the mixed-in method
-# +client+, which will return a class-wide singleton client instance, determined by +client_class+.
-#
-# The client plugins are expected to implement an interface similar to that of Stomp::Client:
-# * <tt>new</tt> should return a connected, ready-to-go client instance.  Note that no arguments are passed in.
-# * <tt>publish_message(queue, message)</tt> should publish the _message_ to the specified _queue_.
-# * <tt>subscribe(queue)</tt> _block_ subscribes to _queue_ and executes _block_ upon receiving a message.
-# * _queue_ names are simple names independent of the message broker or client library.  No "/queue/" prefixes like in Stomp::Client.
-module Puppet::Util::Queue
-  extend Puppet::Util::InstanceLoader
-  instance_load :queue_clients, 'puppet/util/queue'
-
-  # Adds a new class/queue-type pair to the registry.  The _type_ argument is optional; if not provided,
-  # _type_ defaults to a lowercased, underscored symbol programmatically derived from the rightmost
-  # namespace of <em>klass.name</em>.
-  #
-  #   # register with default name +:you+
-  #   register_queue_type(Foo::You)
-  #
-  #   # register with explicit queue type name +:myself+
-  #   register_queue_type(Foo::Me, :myself)
-  #
-  # If the type is already registered, an exception is thrown.  No checking is performed of _klass_,
-  # however; a given class could be registered any number of times, as long as the _type_ differs with
-  # each registration.
-  def self.register_queue_type(klass, type = nil)
-    type ||= queue_type_from_class(klass)
-    raise Puppet::Error, "Queue type #{type} is already registered" if instance_hash(:queue_clients).include?(type)
-    instance_hash(:queue_clients)[type] = klass
-  end
-
-  # Given a queue type symbol, returns the associated +Class+ object.  If the queue type is unknown
-  # (meaning it hasn't been registered with this module), an exception is thrown.
-  def self.queue_type_to_class(type)
-    c = loaded_instance :queue_clients, type
-    raise Puppet::Error, "Queue type #{type} is unknown." unless c
-    c
-  end
-
-  # Given a class object _klass_, returns the programmatic default queue type name symbol for _klass_.
-  # The algorithm is as shown in earlier examples; the last namespace segment of _klass.name_ is taken
-  # and converted from mixed case to underscore-separated lowercase, and interned.
-  #   queue_type_from_class(Foo) -> :foo
-  #   queue_type_from_class(Foo::Too) -> :too
-  #   queue_type_from_class(Foo::ForYouTwo) -> :for_you_too
-  #
-  # The implicit assumption here, consistent with Puppet's approach to plugins in general,
-  # is that all your client modules live in the same namespace, such that reduction to
-  # a flat namespace of symbols is reasonably safe.
-  def self.queue_type_from_class(klass)
-    # convert last segment of classname from studly caps to lower case with underscores, and symbolize
-    klass.name.split('::').pop.sub(/^[A-Z]/) {|c| c.downcase}.gsub(/[A-Z]/) {|c| '_' + c.downcase }.intern
-  end
-
-  # The class object for the client to be used, determined by queue configuration
-  # settings.
-  # Looks to the <tt>:queue_type</tt> configuration entry in the running application for
-  # the default queue type to use.
-  def client_class
-    Puppet::Util::Queue.queue_type_to_class(Puppet[:queue_type])
-  end
-
-  # Returns (instantiating as necessary) the singleton queue client instance, according to the
-  # client_class.  No arguments go to the client class constructor, meaning its up to the client class
-  # to know how to determine its queue message source (presumably through Puppet configuration data).
-  def client
-    @client ||= client_class.new
-  end
-end

data/lib/puppet/util/rails/cache_accumulator.rb

@@ -1,65 +0,0 @@
-require 'puppet/util'
-
-module Puppet::Util::CacheAccumulator
-  def self.included(klass)
-    klass.extend ClassMethods
-  end
-
-  class Base
-    attr_reader :klass, :attribute
-
-    def initialize(klass, attribute)
-      @klass = klass
-      @attribute = attribute
-      @find_or_create = "find_or_create_by_#{@attribute.to_s}".intern
-    end
-
-    def store
-      @store || reset
-    end
-
-    def reset
-      @store = {}
-    end
-
-    def find(*keys)
-      result = nil
-      if keys.length == 1
-        result = store[keys[0]] ||= @klass.send(@find_or_create, *keys)
-      else
-        found, missing = keys.partition {|k| store.include? k}
-        result = found.length
-        result += do_multi_find(missing) if missing.length > 0
-      end
-      result
-    end
-
-    def do_multi_find(keys)
-      result = 0
-      @klass.find(:all, :conditions => {@attribute => keys}).each do |obj|
-        store[obj.send(@attribute)] = obj
-        result += 1
-      end
-      result
-    end
-  end
-
-  module ClassMethods
-    def accumulates(*attributes)
-      attributes.each {|attrib| install_accumulator(attrib)}
-    end
-
-    def accumulators
-      @accumulators ||= {}
-    end
-
-    def install_accumulator(attribute)
-      self.accumulators[attribute] = Base.new(self, attribute)
-      module_eval %{
-        def self.accumulate_by_#{attribute.to_s}(*keys)
-          accumulators[:#{attribute.to_s}].find(*keys)
-        end
-      }
-    end
-  end
-end

data/lib/puppet/util/rails/collection_merger.rb

@@ -1,17 +0,0 @@
-module Puppet::Util::CollectionMerger
-  def ar_hash_merge(db_hash, mem_hash, args)
-    (db_hash.keys | mem_hash.keys).each do |key|
-      if (db_hash[key] && mem_hash[key])
-        # in both, update value
-        args[:modify].call(db_hash[key], mem_hash[key])
-      elsif (db_hash[key])
-        # in db, not memory, delete from database
-        args[:delete].call(db_hash[key])
-      else
-        # in mem, not in db, insert into the database
-        args[:create].call(key, mem_hash[key])
-      end
-    end
-  end
-end
-

data/lib/puppet/util/rails/reference_serializer.rb

@@ -1,32 +0,0 @@
-
-module Puppet::Util::ReferenceSerializer
-  def unserialize_value(val)
-    case val
-    when /^--- /
-      YAML.load(val)
-    when "true"
-      true
-    when "false"
-      false
-    else
-      val
-    end
-  end
-
-  def serialize_value(val)
-    case val
-    when Puppet::Resource
-      YAML.dump(val)
-    when true, false
-      # The database does this for us, but I prefer the
-      # methods be their exact inverses.
-      # Note that this means quoted booleans get returned
-      # as actual booleans, but there doesn't appear to be
-      # a way to fix that while keeping the ability to
-      # search for parameters set to true.
-      val.to_s
-    else
-      val
-    end
-  end
-end

data/lib/puppet/util/rdoc/parser/puppet_parser_rdoc1.rb

@@ -1,19 +0,0 @@
-require 'puppet/util/rdoc/parser/puppet_parser_core.rb'
-
-module RDoc
-  PUPPET_RDOC_VERSION = 1
-
-  # @api private
-  class PuppetParserRDoc1
-    extend ParserFactory
-    include PuppetParserCore
-
-    def create_rdoc_preprocess
-      preprocess = SM::PreProcess.new(@input_file_name, @options.rdoc_include)
-    end
-  end
-
-  # For backwards compatibility
-  # @api private
-  Parser = PuppetParserRDoc1
-end

data/lib/puppet/util/retryaction.rb

@@ -1,47 +0,0 @@
-module Puppet::Util::RetryAction
-  class RetryException < Exception; end
-  class RetryException::NoBlockGiven < RetryException; end
-  class RetryException::NoRetriesGiven < RetryException;end
-  class RetryException::RetriesExceeded < RetryException; end
-
-  def self.retry_action( parameters = { :retry_exceptions => nil, :retries => nil } )
-    # Retry actions for a specified amount of time. This method will allow the final
-    # retry to complete even if that extends beyond the timeout period.
-    unless block_given?
-      raise RetryException::NoBlockGiven
-    end
-
-    raise RetryException::NoRetriesGiven if parameters[:retries].nil?
-    parameters[:retry_exceptions] ||= Hash.new
-
-    failures = 0
-
-    begin
-      yield
-    rescue Exception => e
-      # If we were giving exceptions to catch,
-      # catch the excptions we care about and retry.
-      # All others fail hard
-
-      raise RetryException::RetriesExceeded, "#{parameters[:retries]} exceeded", e.backtrace if parameters[:retries] == 0
-
-      if (not parameters[:retry_exceptions].keys.empty?) and parameters[:retry_exceptions].keys.include?(e.class)
-        Puppet.info("Caught exception #{e.class}:#{e}")
-        Puppet.info(parameters[:retry_exceptions][e.class])
-      elsif (not parameters[:retry_exceptions].keys.empty?)
-        # If the exceptions is not in the list of retry_exceptions re-raise.
-        raise e
-      end
-
-      failures += 1
-      parameters[:retries] -= 1
-
-      # Increase the amount of time that we sleep after every
-      # failed retry attempt.
-      sleep (((2 ** failures) -1) * 0.1)
-
-      retry
-
-    end
-  end
-end