puppet 0.25.5 → 2.6.0

data/lib/puppet/resource/status.rb

@@ -0,0 +1,58 @@
+module Puppet
+  class Resource
+    class Status
+      include Puppet::Util::Tagging
+      include Puppet::Util::Logging
+
+      ATTRIBUTES = [:resource, :node, :version, :file, :line, :current_values, :skipped_reason, :status, :evaluation_time, :change_count]
+      attr_accessor *ATTRIBUTES
+
+      STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled]
+      attr_accessor *STATES
+
+      attr_reader :source_description, :default_log_level, :time, :resource
+
+      # 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
+        end
+      end
+
+      def events
+        @events
+      end
+
+      def initialize(resource)
+        @source_description = resource.path
+        @resource = resource.to_s
+
+        [:file, :line, :version].each do |attr|
+          send(attr.to_s + "=", resource.send(attr))
+        end
+
+        tag(*resource.tags)
+        @time = Time.now
+        @events = []
+      end
+
+      private
+
+      def log_source
+        source_description
+      end
+    end
+  end
+end

data/lib/puppet/resource/type.rb

@@ -0,0 +1,311 @@
+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, :module_name
+  attr_reader :type, :namespace, :arguments, :behaves_like
+
+  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 = [:code, :doc, :line, :file, :parent].inject({}) do |hash, param|
+      next hash unless value = self.send(param)
+      hash[param.to_s] = value
+      hash
+    end
+
+    data['arguments'] = arguments.dup
+
+    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)
+    scope = resource.scope
+
+    if tmp = evaluate_parent_type(resource)
+      scope = tmp
+    end
+
+    scope = subscope(scope, resource) unless resource.title == :main
+
+    set_resource_parameters(resource, scope)
+
+    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])
+  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 our resource type.  This is only possible
+  # for those classes and nodes that don't have any arguments, and is
+  # only useful for things like the 'include' function.
+  def mk_plain_resource(scope)
+    type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
+    resource_type = type == :hostclass ? :class : :node
+
+    # Make sure our parent class has been evaluated, if we have one.
+    if parent
+      parent_resource = scope.catalog.resource(resource_type, parent)
+      unless parent_resource
+        parent_type(scope).mk_plain_resource(scope)
+      end
+    end
+
+    # 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.
+    if resource = scope.catalog.resource(resource_type, name)
+      return resource
+    end
+
+    resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
+    scope.compiler.add_resource(scope, resource)
+    scope.catalog.tag(*resource.tags)
+    resource
+  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 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}", scope.namespaces, 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
+
+    # 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
+
+    scope.setvar("title", resource.title) unless set.include? :title
+    scope.setvar("name", resource.name) unless set.include? :name
+    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?
+  end
+
+  # Create a new subscope in which to evaluate our code.
+  def subscope(scope, resource)
+    scope.newscope :resource => resource, :namespace => self.namespace, :source => self
+  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/puppet/resource/type_collection.rb

@@ -0,0 +1,217 @@
+class Puppet::Resource::TypeCollection
+  attr_reader :environment
+
+  def clear
+    @hostclasses.clear
+    @definitions.clear
+    @nodes.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 <<(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
+    require 'puppet/parser/type_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(namespaces, name, type)
+    #Array("") == [] for some reason
+    namespaces = [namespaces] unless namespaces.is_a?(Array)
+
+    if r = find_fully_qualified(name, type)
+      return r
+    end
+
+    namespaces.each do |namespace|
+      ary = namespace.split("::")
+
+      while ary.length > 0
+        tmp_namespace = ary.join("::")
+        if r = find_partially_qualified(tmp_namespace, name, type)
+          return r
+        end
+
+        # Delete the second to last object, which reduces our namespace by one.
+        ary.pop
+      end
+
+      if result = send(type, name)
+        return result
+      end
+    end
+    nil
+  end
+
+  def find_or_load(namespaces, name, type)
+    name      = name.downcase
+    namespaces = [namespaces] unless namespaces.is_a?(Array)
+    namespaces = namespaces.collect { |ns| ns.downcase }
+
+    # This could be done in the load_until, but the knowledge seems to
+    # belong here.
+    if r = find(namespaces, name, type)
+      return r
+    end
+
+    loader.load_until(namespaces, name) { find(namespaces, name, type) }
+  end
+
+  def find_node(namespaces, name)
+    find("", name, :node)
+  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 perform_initial_import
+    parser = Puppet::Parser::Parser.new(environment)
+    if code = Puppet.settings.uninterpolated_value(:code, environment.to_s) and code != ""
+      parser.string = code
+    else
+      file = Puppet.settings.value(:manifest, environment.to_s)
+      return unless File.exist?(file)
+      parser.file = file
+    end
+    parser.parse
+  rescue => detail
+    msg = "Could not parse for environment #{environment}: #{detail}"
+    error = Puppet::Error.new(msg)
+    error.set_backtrace(detail.backtrace)
+    raise error
+  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
+
+  def find_fully_qualified(name, type)
+    send(type, name.sub(/^::/, ''))
+  end
+
+  def find_partially_qualified(namespace, name, type)
+    send(type, [namespace, name].join("::"))
+  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