puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,155 @@
+require 'time'
+require 'puppet/network/format_support'
+
+module Puppet
+  class Resource
+    class Status
+      include Puppet::Util::Tagging
+      include Puppet::Util::Logging
+      include Puppet::Network::FormatSupport
+
+      attr_accessor :resource, :node, :file, :line, :current_values, :status, :evaluation_time
+
+      STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled]
+      attr_accessor *STATES
+
+      attr_reader :source_description, :containment_path,
+                  :default_log_level, :time, :resource, :change_count,
+                  :out_of_sync_count, :resource_type, :title
+
+      YAML_ATTRIBUTES = %w{@resource @file @line @evaluation_time @change_count
+                           @out_of_sync_count @tags @time @events @out_of_sync
+                           @changed @resource_type @title @skipped @failed
+                           @containment_path}.
+        map(&:to_sym)
+
+
+      def self.from_data_hash(data)
+        obj = self.allocate
+        obj.initialize_from_hash(data)
+        obj
+      end
+
+      def self.from_pson(data)
+        Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+        self.from_data_hash(data)
+      end
+
+      # Provide a boolean method for each of the states.
+      STATES.each do |attr|
+        define_method("#{attr}?") do
+          !! send(attr)
+        end
+      end
+
+      def <<(event)
+        add_event(event)
+        self
+      end
+
+      def add_event(event)
+        @events << event
+        if event.status == 'failure'
+          self.failed = true
+        elsif event.status == 'success'
+          @change_count += 1
+          @changed = true
+        end
+        if event.status != 'audit'
+          @out_of_sync_count += 1
+          @out_of_sync = true
+        end
+      end
+
+      def events
+        @events
+      end
+
+      def failed_because(detail)
+        @real_resource.log_exception(detail, "Could not evaluate: #{detail}")
+        failed = true
+        # There's a contract (implicit unfortunately) that a status of failed
+        # will always be accompanied by an event with some explanatory power.  This
+        # is useful for reporting/diagnostics/etc.  So synthesize an event here
+        # with the exception detail as the message.
+        add_event(@real_resource.event(:name => :resource_error, :status => "failure", :message => detail.to_s))
+      end
+
+      def initialize(resource)
+        @real_resource = resource
+        @source_description = resource.path
+        @containment_path = resource.pathbuilder
+        @resource = resource.to_s
+        @change_count = 0
+        @out_of_sync_count = 0
+        @changed = false
+        @out_of_sync = false
+        @skipped = false
+        @failed = false
+
+        @file = resource.file
+        @line = resource.line
+
+        tag(*resource.tags)
+        @time = Time.now
+        @events = []
+        @resource_type = resource.type.to_s.capitalize
+        @title = resource.title
+      end
+
+      def initialize_from_hash(data)
+        @resource_type = data['resource_type']
+        @title = data['title']
+        @resource = data['resource']
+        @containment_path = data['containment_path']
+        @file = data['file']
+        @line = data['line']
+        @evaluation_time = data['evaluation_time']
+        @change_count = data['change_count']
+        @out_of_sync_count = data['out_of_sync_count']
+        @tags = Puppet::Util::TagSet.new(data['tags'])
+        @time = data['time']
+        @time = Time.parse(@time) if @time.is_a? String
+        @out_of_sync = data['out_of_sync']
+        @changed = data['changed']
+        @skipped = data['skipped']
+        @failed = data['failed']
+
+        @events = data['events'].map do |event|
+          Puppet::Transaction::Event.from_data_hash(event)
+        end
+      end
+
+      def to_data_hash
+        {
+          'title' => @title,
+          'file' => @file,
+          'line' => @line,
+          'resource' => @resource,
+          'resource_type' => @resource_type,
+          'containment_path' => @containment_path,
+          'evaluation_time' => @evaluation_time,
+          'tags' => @tags,
+          'time' => @time.iso8601(9),
+          'failed' => @failed,
+          'changed' => @changed,
+          'out_of_sync' => @out_of_sync,
+          'skipped' => @skipped,
+          'change_count' => @change_count,
+          'out_of_sync_count' => @out_of_sync_count,
+          'events' => @events,
+        }
+      end
+
+      def to_yaml_properties
+        YAML_ATTRIBUTES & super
+      end
+
+      private
+
+      def log_source
+        source_description
+      end
+    end
+  end
+end

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

@@ -0,0 +1,413 @@
+require 'puppet/parser'
+require 'puppet/util/warnings'
+require 'puppet/util/errors'
+require 'puppet/util/inline_docs'
+require 'puppet/parser/ast/leaf'
+require 'puppet/parser/ast/block_expression'
+require 'puppet/dsl'
+
+# Puppet::Resource::Type represents nodes, classes and defined types.
+#
+# It has a standard format for external consumption, usable from the
+# resource_type indirection via rest and the resource_type face. See the
+# {file:api_docs/http_resource_type.md#Schema resource type schema
+# description}.
+#
+# @api public
+class Puppet::Resource::Type
+  Puppet::ResourceType = self
+  include Puppet::Util::InlineDocs
+  include Puppet::Util::Warnings
+  include Puppet::Util::Errors
+
+  RESOURCE_KINDS = [:hostclass, :node, :definition]
+
+  # Map the names used in our documentation to the names used internally
+  RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
+      :hostclass => "class",
+      :node => "node",
+      :definition => "defined_type",
+  }
+  RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
+
+  attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
+  attr_reader :namespace, :arguments, :behaves_like, :module_name
+
+  # Map from argument (aka parameter) names to Puppet Type
+  # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
+  #
+  attr_reader :argument_types
+
+  # This should probably be renamed to 'kind' eventually, in accordance with the changes
+  #  made for serialization and API usability (#14137).  At the moment that seems like
+  #  it would touch a whole lot of places in the code, though.  --cprice 2012-04-23
+  attr_reader :type
+
+  RESOURCE_KINDS.each do |t|
+    define_method("#{t}?") { self.type == t }
+  end
+
+  require 'puppet/indirector'
+  extend Puppet::Indirector
+  indirects :resource_type, :terminus_class => :parser
+
+  def self.from_data_hash(data)
+    name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
+    kind = data.delete('kind') || "definition"
+
+    unless type = RESOURCE_EXTERNAL_NAMES_TO_KINDS[kind]
+      raise ArgumentError, "Unsupported resource kind '#{kind}'"
+    end
+
+    data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
+
+    # External documentation uses "parameters" but the internal name
+    # is "arguments"
+    data[:arguments] = data.delete(:parameters)
+
+    new(type, name, data)
+  end
+
+  def self.from_pson(data)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(data)
+  end
+
+  def to_data_hash
+    data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
+      next hash unless (value = self.send(param)) and (value != "")
+      hash[param.to_s] = value
+      hash
+    end
+
+    # External documentation uses "parameters" but the internal name
+    # is "arguments"
+    data['parameters'] = arguments.dup unless arguments.empty?
+
+    data['name'] = name
+
+    unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)
+      raise ArgumentError, "Unsupported resource kind '#{type}'"
+    end
+    data['kind'] = RESOURCE_KINDS_TO_EXTERNAL_NAMES[type]
+    data
+  end
+
+  # Are we a child of the passed class?  Do a recursive search up our
+  # parentage tree to figure it out.
+  def child_of?(klass)
+    return false unless parent
+
+    return(klass == parent_type ? true : parent_type.child_of?(klass))
+  end
+
+  # Now evaluate the code associated with this class or definition.
+  def evaluate_code(resource)
+
+    static_parent = evaluate_parent_type(resource)
+    scope = static_parent || resource.scope
+
+    scope = scope.newscope(:namespace => namespace, :source => self, :resource => resource) unless resource.title == :main
+    scope.compiler.add_class(name) unless definition?
+
+    set_resource_parameters(resource, scope)
+
+    resource.add_edge_to_stage
+
+    if code
+      if @match # Only bother setting up the ephemeral scope if there are match variables to add into it
+        begin
+          elevel = scope.ephemeral_level
+          scope.ephemeral_from(@match, file, line)
+          code.safeevaluate(scope)
+        ensure
+          scope.unset_ephemeral_var(elevel)
+        end
+      else
+        code.safeevaluate(scope)
+      end
+    end
+
+    evaluate_ruby_code(resource, scope) if ruby_code
+  end
+
+  def initialize(type, name, options = {})
+    @type = type.to_s.downcase.to_sym
+    raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_KINDS.include?(@type)
+
+    name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
+
+    set_name_and_namespace(name)
+
+    [:code, :doc, :line, :file, :parent].each do |param|
+      next unless value = options[param]
+      send(param.to_s + "=", value)
+    end
+
+    set_arguments(options[:arguments])
+    set_argument_types(options[:argument_types])
+
+    @match = nil
+
+    @module_name = options[:module_name]
+  end
+
+  # This is only used for node names, and really only when the node name
+  # is a regexp.
+  def match(string)
+    return string.to_s.downcase == name unless name_is_regex?
+
+    @match = @name.match(string)
+  end
+
+  # Add code from a new instance to our code.
+  def merge(other)
+    fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
+    fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
+    fail "Cannot have code outside of a class/node/define because 'freeze_main' is enabled" if name == "" and Puppet.settings[:freeze_main]
+
+    if parent and other.parent and parent != other.parent
+      fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
+    end
+
+    # We know they're either equal or only one is set, so keep whichever parent is specified.
+    self.parent ||= other.parent
+
+    if other.doc
+      self.doc ||= ""
+      self.doc += other.doc
+    end
+
+    # This might just be an empty, stub class.
+    return unless other.code
+
+    unless self.code
+      self.code = other.code
+      return
+    end
+
+    self.code = Puppet::Parser::ParserFactory.code_merger.concatenate([self, other])
+#    self.code = self.code.sequence_with(other.code)
+  end
+
+  # Make an instance of the resource type, and place it in the catalog
+  # if it isn't in the catalog already.  This is only possible for
+  # classes and nodes.  No parameters are be supplied--if this is a
+  # parameterized class, then all parameters take on their default
+  # values.
+  def ensure_in_catalog(scope, parameters=nil)
+    type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
+    resource_type = type == :hostclass ? :class : :node
+
+    # Do nothing if the resource already exists; this makes sure we don't
+    # get multiple copies of the class resource, which helps provide the
+    # singleton nature of classes.
+    # we should not do this for classes with parameters
+    # if parameters are passed, we should still try to create the resource
+    # even if it exists so that we can fail
+    # this prevents us from being able to combine param classes with include
+    if resource = scope.catalog.resource(resource_type, name) and !parameters
+      return resource
+    end
+    resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
+    assign_parameter_values(parameters, resource)
+    instantiate_resource(scope, resource)
+    scope.compiler.add_resource(scope, resource)
+    resource
+  end
+
+  def instantiate_resource(scope, resource)
+    # Make sure our parent class has been evaluated, if we have one.
+    if parent && !scope.catalog.resource(resource.type, parent)
+      parent_type(scope).ensure_in_catalog(scope)
+    end
+
+    if ['Class', 'Node'].include? resource.type
+      scope.catalog.tag(*resource.tags)
+    end
+  end
+
+  def name
+    return @name unless @name.is_a?(Regexp)
+    @name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
+  end
+
+  def name_is_regex?
+    @name.is_a?(Regexp)
+  end
+
+  def assign_parameter_values(parameters, resource)
+    return unless parameters
+
+    # It'd be nice to assign default parameter values here,
+    # but we can't because they often rely on local variables
+    # created during set_resource_parameters.
+    parameters.each do |name, value|
+      resource.set_parameter name, value
+    end
+  end
+
+  # MQR TODO:
+  #
+  # The change(s) introduced by the fix for #4270 are mostly silly & should be
+  # removed, though we didn't realize it at the time.  If it can be established/
+  # ensured that nodes never call parent_type and that resource_types are always
+  # (as they should be) members of exactly one resource_type_collection the
+  # following method could / should be replaced with:
+  #
+  # def parent_type
+  #   @parent_type ||= parent && (
+  #     resource_type_collection.find_or_load([name],parent,type.to_sym) ||
+  #     fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{resource_type_collection.environment}"
+  #   )
+  # end
+  #
+  # ...and then the rest of the changes around passing in scope reverted.
+  #
+  def parent_type(scope = nil)
+    return nil unless parent
+
+    unless @parent_type
+      raise "Must pass scope to parent_type when called first time" unless scope
+      unless @parent_type = scope.environment.known_resource_types.send("find_#{type}", [name], parent)
+        fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}"
+      end
+    end
+
+    @parent_type
+  end
+
+  # Set any arguments passed by the resource as variables in the scope.
+  def set_resource_parameters(resource, scope)
+    set = {}
+    resource.to_hash.each do |param, value|
+      param = param.to_sym
+      fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
+
+      exceptwrap { scope[param.to_s] = value }
+
+      set[param] = true
+    end
+
+    if @type == :hostclass
+      scope["title"] = resource.title.to_s.downcase unless set.include? :title
+      scope["name"] =  resource.name.to_s.downcase  unless set.include? :name
+    else
+      scope["title"] = resource.title               unless set.include? :title
+      scope["name"] =  resource.name                unless set.include? :name
+    end
+    scope["module_name"] = module_name if module_name and ! set.include? :module_name
+
+    if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
+      scope["caller_module_name"] = caller_name
+    end
+    scope.class_set(self.name,scope) if hostclass? or node?
+
+    # Evaluate the default parameters, now that all other variables are set
+    default_params = resource.set_default_parameters(scope)
+    default_params.each { |param| scope[param] = resource[param] }
+
+    # This has to come after the above parameters so that default values
+    # can use their values
+    resource.validate_complete
+  end
+
+  # Check whether a given argument is valid.
+  def valid_parameter?(param)
+    param = param.to_s
+
+    return true if param == "name"
+    return true if Puppet::Type.metaparam?(param)
+    return false unless defined?(@arguments)
+    return(arguments.include?(param) ? true : false)
+  end
+
+  def set_arguments(arguments)
+    @arguments = {}
+    return if arguments.nil?
+
+    arguments.each do |arg, default|
+      arg = arg.to_s
+      warn_if_metaparam(arg, default)
+      @arguments[arg] = default
+    end
+  end
+
+  # Sets the argument name to Puppet Type hash used for type checking.
+  # Names must correspond to available arguments (they must be defined first).
+  # Arguments not mentioned will not be type-checked. Only supported when parser == "future"
+  #
+  def set_argument_types(name_to_type_hash)
+    @argument_types = {}
+    # Stop here if not running under future parser, the rest requires pops to be initialized
+    # and that the type system is available
+    return unless Puppet[:parser] == 'future' && name_to_type_hash
+    name_to_type_hash.each do |name, t|
+      # catch internal errors
+      unless @arguments.include?(name)
+        raise Puppet::DevError, "Parameter '#{name}' is given a type, but is not a valid parameter."
+      end
+      unless t.is_a? Puppet::Pops::Types::PAnyType
+        raise Puppet::DevError, "Parameter '#{name}' is given a type that is not a Puppet Type, got #{t.class}"
+      end
+      @argument_types[name] = t
+    end
+  end
+
+  private
+
+  def convert_from_ast(name)
+    value = name.value
+    if value.is_a?(Puppet::Parser::AST::Regex)
+      name = value.value
+    else
+      name = value
+    end
+  end
+
+  def evaluate_parent_type(resource)
+    return unless klass = parent_type(resource.scope) and parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name)
+    parent_resource.evaluate unless parent_resource.evaluated?
+    parent_scope(resource.scope, klass)
+  end
+
+  def evaluate_ruby_code(resource, scope)
+    Puppet::DSL::ResourceAPI.new(resource, scope, ruby_code).evaluate
+  end
+
+  # Split an fq name into a namespace and name
+  def namesplit(fullname)
+    ary = fullname.split("::")
+    n = ary.pop || ""
+    ns = ary.join("::")
+    return ns, n
+  end
+
+  def parent_scope(scope, klass)
+    scope.class_scope(klass) || raise(Puppet::DevError, "Could not find scope for #{klass.name}")
+  end
+
+  def set_name_and_namespace(name)
+    if name.is_a?(Regexp)
+      @name = name
+      @namespace = ""
+    else
+      @name = name.to_s.downcase
+
+      # Note we're doing something somewhat weird here -- we're setting
+      # the class's namespace to its fully qualified name.  This means
+      # anything inside that class starts looking in that namespace first.
+      @namespace, ignored_shortname = @type == :hostclass ? [@name, ''] : namesplit(@name)
+    end
+  end
+
+  def warn_if_metaparam(param, default)
+    return unless Puppet::Type.metaparamclass(param)
+
+    if default
+      warnonce "#{param} is a metaparam; this value will inherit to all contained resources in the #{self.name} definition"
+    else
+      raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
+    end
+  end
+end