puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/resource/status.rb

@@ -0,0 +1,79 @@
+module Puppet
+  class Resource
+    class Status
+      include Puppet::Util::Tagging
+      include Puppet::Util::Logging
+
+      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, :default_log_level, :time, :resource
+      attr_reader :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}
+
+      # 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 initialize(resource)
+        @source_description = resource.path
+        @resource = resource.to_s
+        @change_count = 0
+        @out_of_sync_count = 0
+        @changed = false
+        @out_of_sync = false
+        @skipped = false
+        @failed = false
+
+        [:file, :line].each do |attr|
+          send(attr.to_s + "=", resource.send(attr))
+        end
+
+        tag(*resource.tags)
+        @time = Time.now
+        @events = []
+        @resource_type = resource.type.to_s.capitalize
+        @title = resource.title
+      end
+
+      def to_yaml_properties
+        YAML_ATTRIBUTES & instance_variables
+      end
+
+      private
+
+      def log_source
+        source_description
+      end
+    end
+  end
+end

data/lib/vendor/puppet/resource/type.rb

@@ -0,0 +1,344 @@
+require 'puppet/parser/parser'
+require 'puppet/util/warnings'
+require 'puppet/util/errors'
+require 'puppet/util/inline_docs'
+require 'puppet/parser/ast/leaf'
+require 'puppet/dsl'
+
+class Puppet::Resource::Type
+  Puppet::ResourceType = self
+  include Puppet::Util::InlineDocs
+  include Puppet::Util::Warnings
+  include Puppet::Util::Errors
+
+  RESOURCE_SUPERTYPES = [:hostclass, :node, :definition]
+
+  attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
+  attr_reader :type, :namespace, :arguments, :behaves_like, :module_name
+
+  RESOURCE_SUPERTYPES.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_pson(data)
+    name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
+    type = data.delete('type') || "definition"
+
+    data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
+
+    new(type, name, data)
+  end
+
+  def to_pson_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
+
+    data['arguments'] = arguments.dup unless arguments.empty?
+
+    data['name'] = name
+    data['type'] = type
+
+    data
+  end
+
+  def to_pson(*args)
+    to_pson_data_hash.to_pson(*args)
+  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
+
+    code.safeevaluate(scope) if code
+
+    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_SUPERTYPES.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])
+
+    @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?
+
+    @name =~ 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
+
+    array_class = Puppet::Parser::AST::ASTArray
+    self.code = array_class.new(:children => [self.code]) unless self.code.is_a?(array_class)
+
+    if other.code.is_a?(array_class)
+      code.children += other.code.children
+    else
+      code.children << other.code
+    end
+  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)
+    if parameters
+      parameters.each do |k,v|
+        resource.set_parameter(k,v)
+      end
+    end
+    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
+
+  # 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.setvar(param.to_s, value) }
+
+      set[param] = true
+    end
+
+    if @type == :hostclass
+      scope.setvar("title", resource.title.to_s.downcase) unless set.include? :title
+      scope.setvar("name",  resource.name.to_s.downcase ) unless set.include? :name
+    else
+      scope.setvar("title", resource.title              ) unless set.include? :title
+      scope.setvar("name",  resource.name               ) unless set.include? :name
+    end
+    scope.setvar("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.setvar("caller_module_name", caller_name)
+    end
+    scope.class_set(self.name,scope) if hostclass? or node?
+    # Verify that all required arguments are either present or
+    # have been provided with defaults.
+    arguments.each do |param, default|
+      param = param.to_sym
+      next if set.include?(param)
+
+      # Even if 'default' is a false value, it's an AST value, so this works fine
+      fail Puppet::ParseError, "Must pass #{param} to #{resource.ref}" unless default
+
+      value = default.safeevaluate(scope)
+      scope.setvar(param.to_s, value)
+
+      # Set it in the resource, too, so the value makes it to the client.
+      resource[param] = value
+    end
+
+  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
+
+  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"
+    else
+      raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
+    end
+  end
+end
+

data/lib/vendor/puppet/resource/type_collection.rb

@@ -0,0 +1,215 @@
+require 'puppet/parser/type_loader'
+
+class Puppet::Resource::TypeCollection
+  attr_reader :environment
+  attr_accessor :parse_failed
+
+  def clear
+    @hostclasses.clear
+    @definitions.clear
+    @nodes.clear
+    @watched_files.clear
+  end
+
+  def initialize(env)
+    @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
+    @hostclasses = {}
+    @definitions = {}
+    @nodes = {}
+
+    # So we can keep a list and match the first-defined regex
+    @node_list = []
+
+    @watched_files = {}
+  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)
+    find_or_load(namespaces, name, :hostclass)
+  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.values.detect { |file| file.changed? }
+  end
+
+  def version
+    return @version if defined?(@version)
+
+    if environment[:config_version] == ""
+      @version = Time.now.to_i
+      return @version
+    end
+
+    @version = Puppet::Util.execute([environment[:config_version]]).strip
+
+  rescue Puppet::ExecutionFailure => e
+    raise Puppet::ParseError, "Unable to set config_version: #{e.message}"
+  end
+
+  def watch_file(file)
+    @watched_files[file] = Puppet::Util::LoadedFile.new(file)
+  end
+
+  def watching_file?(file)
+    @watched_files.include?(file)
+  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)
+    resolve_namespaces(namespaces, name).each do |fqname|
+      if result = send(type, fqname) || loader.try_load_fqname(type, fqname)
+        return result
+      end
+    end
+
+    # Nothing found.
+    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/lib/vendor/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