puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/reports/rrdgraph.rb

@@ -95,8 +95,8 @@ Puppet::Reports.register_report(:rrdgraph) do
 
     unless File.directory?(hostdir) and FileTest.writable?(hostdir)
       # Some hackishness to create the dir with all of the right modes and ownership
-      config = Puppet::Util::Settings.new
-      config.setdefaults(:reports, :hostdir => {:default => hostdir, :owner => 'service', :mode => 0755, :group => 'service', :desc => "eh"})
+      config = Puppet::Settings.new
+      config.define_settings(:reports, :hostdir => {:type => :directory, :default => hostdir, :owner => 'service', :mode => 0755, :group => 'service', :desc => "eh"})
 
       # This creates the dir.
       config.use(:reports)

data/lib/puppet/reports/store.rb

@@ -41,8 +41,7 @@ Puppet::Reports.register_report(:store) do
       end
       FileUtils.mv(f.path, file)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.warning "Could not write report for #{host} at #{file}: #{detail}"
+      Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
     end
 
     # Only testing cares about the return value

data/lib/puppet/reports/tagmail.rb

@@ -146,9 +146,9 @@ Puppet::Reports.register_report(:tagmail) do
             end
           end
         rescue => detail
-          puts detail.backtrace if Puppet[:debug]
-          raise Puppet::Error,
-            "Could not send report emails through smtp: #{detail}"
+          message = "Could not send report emails through smtp: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       elsif Puppet[:sendmail] != ""
         begin
@@ -163,9 +163,9 @@ Puppet::Reports.register_report(:tagmail) do
             end
           end
         rescue => detail
-          puts detail.backtrace if Puppet[:debug]
-          raise Puppet::Error,
-            "Could not send report emails via sendmail: #{detail}"
+          message = "Could not send report emails via sendmail: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       else
         raise Puppet::Error, "SMTP server is unset and could not find sendmail"

data/lib/puppet/resource.rb

@@ -28,8 +28,8 @@ class Puppet::Resource
   ATTRIBUTES = [:file, :line, :exported]
 
   def self.from_pson(pson)
-    raise ArgumentError, "No resource type provided in serialized data" unless type = pson['type']
-    raise ArgumentError, "No resource title provided in serialized data" unless title = pson['title']
+    raise ArgumentError, "No resource type provided in pson data" unless type = pson['type']
+    raise ArgumentError, "No resource title provided in pson data" unless title = pson['title']
 
     resource = new(type, title)
 
@@ -47,6 +47,8 @@ class Puppet::Resource
       end
     end
 
+    resource.exported ||= false
+
     resource
   end
 
@@ -174,6 +176,14 @@ class Puppet::Resource
     end
   end
 
+  def class?
+    @is_class ||= @type == "Class"
+  end
+
+  def stage?
+    @is_stage ||= @type.to_s.downcase == "stage"
+  end
+
   # Create our resource.
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
@@ -188,7 +198,7 @@ class Puppet::Resource
 
     @type = munge_type_name(@type)
 
-    if @type == "Class"
+    if self.class?
       @title = :main if @title == ""
       @title = munge_type_name(@title)
     end
@@ -202,7 +212,7 @@ class Puppet::Resource
 
     @reference = self # for serialization compatibility with 0.25.x
     if strict? and ! resource_type
-      if @type == 'Class'
+      if self.class?
         raise ArgumentError, "Could not find declared class #{title}"
       else
         raise ArgumentError, "Invalid resource type #{type}"
@@ -216,15 +226,15 @@ class Puppet::Resource
 
   # Find our resource.
   def resolve
-    return(catalog ? catalog.resource(to_s) : nil)
+    catalog ? catalog.resource(to_s) : nil
   end
 
   def resource_type
-    case type
+    @rstype ||= case type
     when "Class"; known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; known_resource_types.node(title)
     else
-      Puppet::Type.type(type.to_s.downcase.to_sym) || known_resource_types.definition(type)
+      Puppet::Type.type(type) || known_resource_types.definition(type)
     end
   end
 
@@ -246,7 +256,7 @@ class Puppet::Resource
   end
 
   def key_attributes
-    return(resource_type.respond_to? :key_attributes) ? resource_type.key_attributes : [:name]
+    resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name]
   end
 
   # Convert our resource to Puppet code.
@@ -283,61 +293,54 @@ class Puppet::Resource
     end
   end
 
-  # Translate our object to a backward-compatible transportable object.
-  def to_trans
-    if builtin_type? and type.downcase.to_s != "stage"
-      result = to_transobject
-    else
-      result = to_transbucket
-    end
-
-    result.file = self.file
-    result.line = self.line
-
-    result
+  def name
+    # this is potential namespace conflict
+    # between the notion of an "indirector name"
+    # and a "resource name"
+    [ type, title ].join('/')
   end
 
-  def to_trans_ref
-    [type.to_s, title.to_s]
-  end
+  def set_default_parameters(scope)
+    return [] unless resource_type and resource_type.respond_to?(:arguments)
+
+    result = []
 
-  # Create an old-style TransObject instance, for builtin resource types.
-  def to_transobject
-    # Now convert to a transobject
-    result = Puppet::TransObject.new(title, type)
-    to_hash.each do |p, v|
-      if v.is_a?(Puppet::Resource)
-        v = v.to_trans_ref
-      elsif v.is_a?(Array)
-        v = v.collect { |av|
-          av = av.to_trans_ref if av.is_a?(Puppet::Resource)
-          av
-        }
+    resource_type.arguments.each do |param, default|
+      param = param.to_sym
+      next if parameters.include?(param)
+      unless is_a?(Puppet::Parser::Resource)
+        fail Puppet::DevError, "Cannot evaluate default parameters for #{self} - not a parser resource"
       end
 
-      # If the value is an array with only one value, then
-      # convert it to a single value.  This is largely so that
-      # the database interaction doesn't have to worry about
-      # whether it returns an array or a string.
-      result[p.to_s] = if v.is_a?(Array) and v.length == 1
-        v[0]
-          else
-            v
-              end
-    end
+      # Consult external data bindings for class parameter values which must be
+      # namespaced in the backend.
+      #
+      # Example:
+      #
+      #   class foo($port){ ... }
+      #
+      # We make a request to the backend for the key 'foo::port' not 'foo'
+      #
+      external_value = nil
+      if resource_type.type == :hostclass
+        namespaced_param = "#{resource_type.name}::#{param}"
+        external_value = Puppet::DataBinding.indirection.find(
+          namespaced_param, :host => scope.host, :environment => scope.environment.to_s, :facts => scope.facts.values)
+      end
 
-    result.tags = self.tags
+      if external_value.nil?
+        next if default.nil?
+        value = default.safeevaluate(scope)
+      else
+        value = external_value
+      end
 
+      self[param] = value
+      result << param
+    end
     result
   end
 
-  def name
-    # this is potential namespace conflict
-    # between the notion of an "indirector name"
-    # and a "resource name"
-    [ type, title ].join('/')
-  end
-
   def to_resource
     self
   end
@@ -346,6 +349,19 @@ class Puppet::Resource
     resource_type.valid_parameter?(name)
   end
 
+  # Verify that all required arguments are either present or
+  # have been provided with defaults.
+  # Must be called after 'set_default_parameters'.  We can't join the methods
+  # because Type#set_parameters needs specifically ordered behavior.
+  def validate_complete
+    return unless resource_type and resource_type.respond_to?(:arguments)
+
+    resource_type.arguments.each do |param, default|
+      param = param.to_sym
+      fail Puppet::ParseError, "Must pass #{param} to #{self}" unless parameters.include?(param)
+    end
+  end
+
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
@@ -387,17 +403,6 @@ class Puppet::Resource
     end
   end
 
-  # Create an old-style TransBucket instance, for non-builtin resource types.
-  def to_transbucket
-    bucket = Puppet::TransBucket.new([])
-
-    bucket.type = self.type
-    bucket.name = self.title
-
-    # TransBuckets don't support parameters, which is why they're being deprecated.
-    bucket
-  end
-
   def extract_parameters(params)
     params.each do |param, value|
       validate_parameter(param) if strict?

data/lib/puppet/resource/catalog.rb

@@ -44,6 +44,9 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
   # Some metadata to help us compile and generally respond to the current state.
   attr_accessor :client_version, :server_version
 
+  # The environment for this catalog
+  attr_accessor :environment
+
   # Add classes to our class list.
   def add_class(*classes)
     classes.each do |klass|
@@ -143,11 +146,9 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
         Puppet::Util::Log.close(transaction.report) if register_report
       end
     rescue Puppet::Error => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not apply complete catalog: #{detail}"
+      Puppet.log_exception(detail, "Could not apply complete catalog: #{detail}")
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Got an uncaught exception of type #{detail.class}: #{detail}"
+      Puppet.log_exception(detail, "Got an uncaught exception of type #{detail.class}: #{detail}")
     ensure
       # Don't try to store state unless we're a host config
       # too recursive.
@@ -193,59 +194,6 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
     resource
   end
 
-  # Turn our catalog graph into an old-style tree of TransObjects and TransBuckets.
-  # LAK:NOTE(20081211): This is a  pre-0.25 backward compatibility method.
-  # It can be removed as soon as xmlrpc is killed.
-  def extract
-    top = nil
-    current = nil
-    buckets = {}
-
-    unless main = resource(:stage, "main")
-      raise Puppet::DevError, "Could not find 'main' stage; cannot generate catalog"
-    end
-
-    if stages = vertices.find_all { |v| v.type == "Stage" and v.title != "main" } and ! stages.empty?
-      Puppet.warning "Stages are not supported by 0.24.x client; stage(s) #{stages.collect { |s| s.to_s }.join(', ') } will be ignored"
-    end
-
-    bucket = nil
-    walk(main, :out) do |source, target|
-      # The sources are always non-builtins.
-      unless tmp = buckets[source.to_s]
-        if tmp = buckets[source.to_s] = source.to_trans
-          bucket = tmp
-        else
-          # This is because virtual resources return nil.  If a virtual
-          # container resource contains realized resources, we still need to get
-          # to them.  So, we keep a reference to the last valid bucket
-          # we returned and use that if the container resource is virtual.
-        end
-      end
-      bucket = tmp || bucket
-      if child = target.to_trans
-        raise "No bucket created for #{source}" unless bucket
-        bucket.push child
-
-        # It's important that we keep a reference to any TransBuckets we've created, so
-        # we don't create multiple buckets for children.
-        buckets[target.to_s] = child unless target.builtin?
-      end
-    end
-
-    # Retrieve the bucket for the top-level scope and set the appropriate metadata.
-    unless result = buckets[main.to_s]
-      # This only happens when the catalog is entirely empty.
-      result = buckets[main.to_s] = main.to_trans
-    end
-
-    result.classes = classes
-
-    # Clear the cache to encourage the GC
-    buckets.clear
-    result
-  end
-
   # Make sure all of our resources are "finished".
   def finalize
     make_default_resources
@@ -452,6 +400,10 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
       result.version = version
     end
 
+    if environment = data['environment']
+      result.environment = environment
+    end
+
     if resources = data['resources']
       resources = PSON.parse(resources) if resources.is_a?(String)
       resources.each do |res|
@@ -503,6 +455,7 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
         'tags'      => tags,
         'name'      => name,
         'version'   => version,
+        'environment' => environment.to_s,
         'resources' => vertices.collect { |v| v.to_pson_data_hash },
         'edges'     => edges.   collect { |e| e.to_pson_data_hash },
         'classes'   => classes
@@ -592,6 +545,7 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
     result = self.class.new(self.name)
 
     result.version = self.version
+    result.environment = self.environment
 
     map = {}
     vertices.each do |resource|
@@ -605,9 +559,6 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
       if resource.class == Puppet::Resource
         resource = resource.dup
         resource.catalog = result
-      elsif resource.is_a?(Puppet::TransObject)
-        resource = resource.dup
-        resource.catalog = result
       elsif resource.is_a?(Puppet::Parser::Resource)
         resource = resource.to_resource
         resource.catalog = result

data/lib/puppet/resource/status.rb

@@ -12,14 +12,10 @@ module Puppet
       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}
-
-
-      def self.from_pson(data)
-        obj = self.allocate
-        obj.initialize_from_hash(data)
-        obj
-      end
+      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}.
+        map(&:to_sym)
 
       # Provide a boolean method for each of the states.
       STATES.each do |attr|
@@ -61,9 +57,8 @@ module Puppet
         @skipped = false
         @failed = false
 
-        [:file, :line].each do |attr|
-          send(attr.to_s + "=", resource.send(attr))
-        end
+        @file = resource.file
+        @line = resource.line
 
         tag(*resource.tags)
         @time = Time.now
@@ -72,27 +67,6 @@ module Puppet
         @title = resource.title
       end
 
-      def initialize_from_hash(data)
-        @resource_type = data['resource_type']
-        @title = data['title']
-        @resource = data['resource']
-        @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 = data['tags']
-        @time = data['time']
-        @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_pson(event)
-        end
-      end
-
       def to_yaml_properties
         YAML_ATTRIBUTES & instance_variables
       end

data/lib/puppet/resource/type.rb

@@ -11,12 +11,31 @@ class Puppet::Resource::Type
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
-  RESOURCE_SUPERTYPES = [:hostclass, :node, :definition]
+  RESOURCE_KINDS = [:hostclass, :node, :definition]
+
+  # We have reached a point where we've established some naming conventions
+  #  in our documentation that don't entirely match up with our internal names
+  #  for things.  Ideally we'd change the internal representation to match the
+  #  conventions expressed in our docs, but that would be a fairly far-reaching
+  #  and risky change.  For the time being, we're settling for mapping the
+  #  internal names to the external ones (and vice-versa) during serialization
+  #  and deserialization.  These two hashes is here to help with that mapping.
+  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 :type, :namespace, :arguments, :behaves_like, :module_name
+  attr_reader :namespace, :arguments, :behaves_like, :module_name
 
-  RESOURCE_SUPERTYPES.each do |t|
+  # 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
 
@@ -26,13 +45,34 @@ class Puppet::Resource::Type
 
   def self.from_pson(data)
     name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
-    type = data.delete('type') || "definition"
+    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 }
 
+    # This is a bit of a hack; when we serialize, we use the term "parameters" because that
+    #  is the terminology that we use in our documentation.  However, internally to this
+    #  class we use the term "arguments".  Ideally we'd change the implementation to be consistent
+    #  with the documentation, but that would be challenging right now because it could potentially
+    #  touch a lot of places in the code, not to mention that we already have another meaning for
+    #  "parameters" internally.  So, for now, we will simply transform the internal "arguments"
+    #  value to "parameters" when serializing, and the opposite when deserializing.
+    #     --cprice 2012-04-23
+    data[:arguments] = data.delete(:parameters)
+
     new(type, name, data)
   end
 
+  # This method doesn't seem like it has anything to do with PSON in particular, and it shouldn't.
+  #  It's just transforming to a simple object that can be serialized and de-serialized via
+  #  any transport format.  Should probably be renamed if we get a chance to clean up our
+  #  serialization / deserialization, and there are probably many other similar methods in
+  #  other classes.
+  #  --cprice 2012-04-23
+
   def to_pson_data_hash
     data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
       next hash unless (value = self.send(param)) and (value != "")
@@ -40,14 +80,34 @@ class Puppet::Resource::Type
       hash
     end
 
-    data['arguments'] = arguments.dup unless arguments.empty?
+    # This is a bit of a hack; when we serialize, we use the term "parameters" because that
+    #  is the terminology that we use in our documentation.  However, internally to this
+    #  class we use the term "arguments".  Ideally we'd change the implementation to be consistent
+    #  with the documentation, but that would be challenging right now because it could potentially
+    #  touch a lot of places in the code, not to mention that we already have another meaning for
+    #  "parameters" internally.  So, for now, we will simply transform the internal "arguments"
+    #  value to "parameters" when serializing, and the opposite when deserializing.
+    #     --cprice 2012-04-23
+    data['parameters'] = arguments.dup unless arguments.empty?
 
     data['name'] = name
-    data['type'] = type
 
+    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
 
+  # It seems wrong that we have a 'to_pson' method on this class, but not a 'to_yaml'.
+  #  As a result, if you use the REST API to retrieve one or more objects of this type,
+  #  you will receive different data if you use 'Accept: yaml' vs 'Accept: pson'.  That
+  #  seems really, really wrong.  The "Accept" header should never affect what data is
+  #  being returned--only the format of the data.  If the data itself is going to differ,
+  #  then there should be a different request URL.  Documenting the REST API becomes
+  #  a much more complex problem when the "Accept" header can change the semantics
+  #  of the response.  --cprice 2012-04-23
+
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
@@ -80,7 +140,7 @@ class Puppet::Resource::Type
 
   def initialize(type, name, options = {})
     @type = type.to_s.downcase.to_sym
-    raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_SUPERTYPES.include?(@type)
+    raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_KINDS.include?(@type)
 
     name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
 
@@ -160,11 +220,7 @@ class Puppet::Resource::Type
       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
+    assign_parameter_values(parameters, resource)
     instantiate_resource(scope, resource)
     scope.compiler.add_resource(scope, resource)
     resource
@@ -190,6 +246,18 @@ class Puppet::Resource::Type
     @name.is_a?(Regexp)
   end
 
+  def assign_parameter_values(parameters, resource)
+    return unless parameters
+    scope = resource.scope || {}
+
+    # 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 
@@ -227,40 +295,32 @@ class Puppet::Resource::Type
       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) }
+      exceptwrap { scope[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
+      scope["title"] = resource.title.to_s.downcase unless set.include? :title
+      scope["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
+      scope["title"] = resource.title               unless set.include? :title
+      scope["name"] =  resource.name                unless set.include? :name
     end
-    scope.setvar("module_name", module_name) if module_name and ! set.include? :module_name
+    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.setvar("caller_module_name", caller_name)
+      scope["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
+    # Evaluate the default parameters, now that all other variables are set
+    default_params = resource.set_default_parameters(scope)
+    default_params.each { |param| scope[param.to_s] = 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.
@@ -335,7 +395,7 @@ class Puppet::Resource::Type
     return unless Puppet::Type.metaparamclass(param)
 
     if default
-      warnonce "#{param} is a metaparam; this value will inherit to all contained resources"
+      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