puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/resource/type_collection.rb

@@ -0,0 +1,230 @@
+require 'puppet/parser/type_loader'
+require 'puppet/util/file_watcher'
+require 'puppet/util/warnings'
+
+class Puppet::Resource::TypeCollection
+  attr_reader :environment
+  attr_accessor :parse_failed
+
+  include Puppet::Util::Warnings
+
+  def clear
+    @hostclasses.clear
+    @definitions.clear
+    @nodes.clear
+    @watched_files.clear
+    @notfound.clear
+  end
+
+  def initialize(env)
+    @environment = env
+    @hostclasses = {}
+    @definitions = {}
+    @nodes = {}
+    @notfound = {}
+
+    # So we can keep a list and match the first-defined regex
+    @node_list = []
+
+    @watched_files = Puppet::Util::FileWatcher.new
+  end
+
+  def import_ast(ast, modname)
+    ast.instantiate(modname).each do |instance|
+      add(instance)
+    end
+  end
+
+  def inspect
+    "TypeCollection" + { :hostclasses => @hostclasses.keys, :definitions => @definitions.keys, :nodes => @nodes.keys }.inspect
+  end
+
+  def <<(thing)
+    add(thing)
+    self
+  end
+
+  def add(instance)
+    if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
+      other.merge(instance)
+      return other
+    end
+    method = "add_#{instance.type}"
+    send(method, instance)
+    instance.resource_type_collection = self
+    instance
+  end
+
+  def add_hostclass(instance)
+    dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
+    dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
+
+    @hostclasses[instance.name] = instance
+    instance
+  end
+
+  def hostclass(name)
+    @hostclasses[munge_name(name)]
+  end
+
+  def add_node(instance)
+    dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
+
+    @node_list << instance
+    @nodes[instance.name] = instance
+    instance
+  end
+
+  def loader
+    @loader ||= Puppet::Parser::TypeLoader.new(environment)
+  end
+
+  def node(name)
+    name = munge_name(name)
+
+    if node = @nodes[name]
+      return node
+    end
+
+    @node_list.each do |node|
+      next unless node.name_is_regex?
+      return node if node.match(name)
+    end
+    nil
+  end
+
+  def node_exists?(name)
+    @nodes[munge_name(name)]
+  end
+
+  def nodes?
+    @nodes.length > 0
+  end
+
+  def add_definition(instance)
+    dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
+    dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
+    @definitions[instance.name] = instance
+  end
+
+  def definition(name)
+    @definitions[munge_name(name)]
+  end
+
+  def find_node(namespaces, name)
+    @nodes[munge_name(name)]
+  end
+
+  def find_hostclass(namespaces, name, options = {})
+    find_or_load(namespaces, name, :hostclass, options)
+  end
+
+  def find_definition(namespaces, name)
+    find_or_load(namespaces, name, :definition)
+  end
+
+  [:hostclasses, :nodes, :definitions].each do |m|
+    define_method(m) do
+      instance_variable_get("@#{m}").dup
+    end
+  end
+
+  def require_reparse?
+    @parse_failed || stale?
+  end
+
+  def stale?
+    @watched_files.changed?
+  end
+
+  def version
+    if !defined?(@version)
+      if environment.config_version.nil? || environment.config_version == ""
+        @version = Time.now.to_i
+      else
+        @version = Puppet::Util::Execution.execute([environment.config_version]).strip
+      end
+    end
+
+    @version
+  rescue Puppet::ExecutionFailure => e
+    raise Puppet::ParseError, "Execution of config_version command `#{environment.config_version}` failed: #{e.message}", e.backtrace
+  end
+
+  def watch_file(filename)
+    @watched_files.watch(filename)
+  end
+
+  def watching_file?(filename)
+    @watched_files.watching?(filename)
+  end
+
+  private
+
+  # Return a list of all possible fully-qualified names that might be
+  # meant by the given name, in the context of namespaces.
+  def resolve_namespaces(namespaces, name)
+    name      = name.downcase
+    if name =~ /^::/
+      # name is explicitly fully qualified, so just return it, sans
+      # initial "::".
+      return [name.sub(/^::/, '')]
+    end
+    if name == ""
+      # The name "" has special meaning--it always refers to a "main"
+      # hostclass which contains all toplevel resources.
+      return [""]
+    end
+
+    namespaces = [namespaces] unless namespaces.is_a?(Array)
+    namespaces = namespaces.collect { |ns| ns.downcase }
+
+    result = []
+    namespaces.each do |namespace|
+      ary = namespace.split("::")
+
+      # Search each namespace nesting in innermost-to-outermost order.
+      while ary.length > 0
+        result << "#{ary.join("::")}::#{name}"
+        ary.pop
+      end
+
+      # Finally, search the toplevel namespace.
+      result << name
+    end
+
+    return result.uniq
+  end
+
+  # Resolve namespaces and find the given object.  Autoload it if
+  # necessary.
+  def find_or_load(namespaces, name, type, options = {})
+    searchspace = options[:assume_fqname] ? [name].flatten : resolve_namespaces(namespaces, name)
+    searchspace.each do |fqname|
+      result = send(type, fqname)
+      unless result
+        if @notfound[fqname] and Puppet[:ignoremissingtypes]
+          # do not try to autoload if we already tried and it wasn't conclusive
+          # as this is a time consuming operation. Warn the user.
+          debug_once "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
+        else
+          result = loader.try_load_fqname(type, fqname)
+          @notfound[fqname] = result.nil?
+        end
+      end
+      return result if result
+    end
+
+    return nil
+  end
+
+  def munge_name(name)
+    name.to_s.downcase
+  end
+
+  def dupe_check(instance, hash)
+    return unless dupe = hash[instance.name]
+    message = yield dupe
+    instance.fail Puppet::ParseError, message
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/resource/type_collection_helper.rb

@@ -0,0 +1,7 @@
+require 'puppet/resource/type_collection'
+
+module Puppet::Resource::TypeCollectionHelper
+  def known_resource_types
+    environment.known_resource_types
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/run.rb

@@ -0,0 +1,109 @@
+require 'puppet/agent'
+require 'puppet/configurer'
+require 'puppet/indirector'
+
+# A basic class for running the agent.  Used by
+# `puppet kick` to kick off agents remotely.
+class Puppet::Run
+  extend Puppet::Indirector
+  indirects :run, :terminus_class => :local
+
+  attr_reader :status, :background, :options
+
+  def agent
+    # Forking disabled for "puppet kick" runs
+    Puppet::Agent.new(Puppet::Configurer, false)
+  end
+
+  def background?
+    background
+  end
+
+  def initialize(options = {})
+    if options.include?(:background)
+      @background = options[:background]
+      options.delete(:background)
+    end
+
+    valid_options = [:tags, :ignoreschedules, :pluginsync]
+    options.each do |key, value|
+      raise ArgumentError, "Run does not accept #{key}" unless valid_options.include?(key)
+    end
+
+    @options = options
+  end
+
+  def initialize_from_hash(hash)
+    @options = {}
+
+    hash['options'].each do |key, value|
+      @options[key.to_sym] = value
+    end
+
+    @background = hash['background']
+    @status = hash['status']
+  end
+
+  def log_run
+    msg = ""
+    msg += "triggered run" % if options[:tags]
+      msg += " with tags #{options[:tags].inspect}"
+    end
+
+    msg += " ignoring schedules" if options[:ignoreschedules]
+
+    Puppet.notice msg
+  end
+
+  def run
+    if agent.running?
+      @status = "running"
+      return self
+    end
+
+    log_run
+
+    if background?
+      Thread.new { agent.run(options) }
+    else
+      agent.run(options)
+    end
+
+    @status = "success"
+
+    self
+  end
+
+  def self.from_hash(hash)
+    obj = allocate
+    obj.initialize_from_hash(hash)
+    obj
+  end
+
+  def self.from_data_hash(data)
+    if data['options']
+      return from_hash(data)
+    end
+
+    options = { :pluginsync => Puppet[:pluginsync] }
+
+    data.each do |key, value|
+      options[key.to_sym] = value
+    end
+
+    new(options)
+  end
+
+  def self.from_pson(hash)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(hash)
+  end
+
+  def to_data_hash
+    {
+      :options => @options,
+      :background => @background,
+      :status => @status
+    }
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/scheduler.rb

@@ -0,0 +1,16 @@
+module Puppet::Scheduler
+  require 'puppet/scheduler/job'
+  require 'puppet/scheduler/splay_job'
+  require 'puppet/scheduler/scheduler'
+  require 'puppet/scheduler/timer'
+
+  module_function
+
+  def create_job(interval, splay=false, splay_limit=0, &block)
+    if splay
+      Puppet::Scheduler::SplayJob.new(interval, splay_limit, &block)
+    else
+      Puppet::Scheduler::Job.new(interval, &block)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/scheduler/job.rb

@@ -0,0 +1,53 @@
+module Puppet::Scheduler
+  class Job
+    attr_reader :run_interval
+    attr_accessor :last_run
+    attr_accessor :start_time
+
+    def initialize(run_interval, &block)
+      self.run_interval = run_interval
+      @last_run = nil
+      @run_proc = block
+      @enabled = true
+    end
+
+    def run_interval=(interval)
+      @run_interval = [interval, 0].max
+    end
+
+    def ready?(time)
+      if @last_run
+        @last_run + @run_interval <= time
+      else
+        true
+      end
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def interval_to_next_from(time)
+      if ready?(time)
+        0
+      else
+        @run_interval - (time - @last_run)
+      end
+    end
+
+    def run(now)
+      @last_run = now
+      if @run_proc
+        @run_proc.call(self)
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/scheduler/scheduler.rb

@@ -0,0 +1,44 @@
+module Puppet::Scheduler
+  class Scheduler
+    def initialize(timer=Puppet::Scheduler::Timer.new)
+      @timer = timer
+    end
+
+    def run_loop(jobs)
+      mark_start_times(jobs, @timer.now)
+      while not enabled(jobs).empty?
+        @timer.wait_for(min_interval_to_next_run_from(jobs, @timer.now))
+        run_ready(jobs, @timer.now)
+      end
+    end
+
+    private
+
+    def enabled(jobs)
+      jobs.select(&:enabled?)
+    end
+
+    def mark_start_times(jobs, start_time)
+      jobs.each do |job|
+        job.start_time = start_time
+      end
+    end
+
+    def min_interval_to_next_run_from(jobs, from_time)
+      enabled(jobs).map do |j|
+        j.interval_to_next_from(from_time)
+      end.min
+    end
+
+    def run_ready(jobs, at_time)
+      enabled(jobs).each do |j|
+        # This check intentionally happens right before each run,
+        # instead of filtering on ready schedulers, since one may adjust
+        # the readiness of a later one
+        if j.ready?(at_time)
+          j.run(at_time)
+        end
+      end
+    end
+  end
+end