puppet 0.24.9 → 0.25.0

data/lib/puppet/relationship.rb

@@ -6,48 +6,52 @@
 # subscriptions are permanent associations determining how different
 # objects react to an event
 
+require 'puppet/util/json'
+
 # This is Puppet's class for modeling edges in its configuration graph.
 # It used to be a subclass of GRATR::Edge, but that class has weird hash
 # overrides that dramatically slow down the graphing.
 class Puppet::Relationship
-    attr_accessor :source, :target, :label
+    extend Puppet::Util::Json
+    attr_accessor :source, :target, :callback
 
-    # Return the callback
-    def callback
-        if label
-            label[:callback]
-        else
-            nil
+    attr_reader :event
+
+    def self.from_json(json)
+        source = json["source"]
+        target = json["target"]
+
+        args = {}
+        if event = json["event"]
+            args[:event] = event
         end
+        if callback = json["callback"]
+            args[:callback] = callback
+        end
+
+        new(source, target, args)
     end
     
-    # Return our event.
-    def event
-        if label
-            label[:event]
-        else
-            nil
+    def event=(event)
+        if event != :NONE and ! callback
+            raise ArgumentError, "You must pass a callback for non-NONE events"
         end
+        @event = event
     end
-    
-    def initialize(source, target, label = {})
-        if label
-            unless label.is_a?(Hash)
-                raise ArgumentError, "Relationship labels must be a hash"
-            end
-        
-            if label[:event] and label[:event] != :NONE and ! label[:callback]
-                raise ArgumentError, "You must pass a callback for non-NONE events"
+
+    def initialize(source, target, options = {})
+        @source, @target = source, target
+
+        options = (options || {}).inject({}) { |h,a| h[a[0].to_sym] = a[1]; h }
+        [:callback, :event].each do |option|
+            if value = options[option]
+                send(option.to_s + "=", value)
             end
-        else
-            label = {}
         end
-
-        @source, @target, @label = source, target, label
     end
-    
+
     # Does the passed event match our event?  This is where the meaning
-    # of :NONE comes from. 
+    # of :NONE comes from.
     def match?(event)
         if self.event.nil? or event == :NONE or self.event == :NONE
             return false
@@ -57,13 +61,36 @@ class Puppet::Relationship
             return false
         end
     end
-    
+
+    def label
+        result = {}
+        result[:callback] = callback if callback
+        result[:event] = event if event
+        result
+    end
+
     def ref
         "%s => %s" % [source, target]
     end
 
+    def to_json(*args)
+        data = {
+            'source' => source.to_s,
+            'target' => target.to_s
+        }
+
+        ["event", "callback"].each do |attr|
+            next unless value = send(attr)
+            data[attr] = value
+        end
+
+        {
+            'json_class' => self.class.to_s,
+            'data' => data
+        }.to_json(*args)
+    end
+
     def to_s
         ref
     end
 end
-

data/lib/puppet/reports/rrdgraph.rb

@@ -3,21 +3,21 @@ Puppet::Reports.register_report(:rrdgraph) do
         must have the Ruby RRDtool library installed to use this report, which
         you can get from `the RubyRRDTool RubyForge page`_.  This package may also
         be available as ``ruby-rrd`` or ``rrdtool-ruby`` in your distribution's package
-        management system.  The library and/or package will both require the binary 
+        management system.  The library and/or package will both require the binary
         ``rrdtool`` package from your distribution to be installed.
 
         .. _the RubyRRDTool RubyForge page: http://rubyforge.org/projects/rubyrrdtool/
-        
+
         This report will create, manage, and graph RRD database files for each
         of the metrics generated during transactions, and it will create a
         few simple html files to display the reporting host's graphs.  At this
         point, it will not create a common index file to display links to
         all hosts.
-        
+
         All RRD files and graphs get created in the ``rrddir`` directory.  If
         you want to serve these publicly, you should be able to just alias that
         directory in a web server.
-    
+
         If you really know what you're doing, you can tune the ``rrdinterval``,
         which defaults to the ``runinterval``."
 

data/lib/puppet/reports/store.rb

@@ -5,14 +5,14 @@ Puppet::Reports.register_report(:store) do
 
     desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
         and this just stores the file on disk, in the ``reportdir`` directory.
-        
+
         These files collect quickly -- one every half hour -- so it is a good idea
         to perform some maintenance on them if you use this report (it's the only
         default report)."
 
     def mkclientdir(client, dir)
         config = Puppet::Util::Settings.new
-        config.setdefaults("reportclient-#{client}",
+        config.setdefaults("reportclient-#{client}".to_sym,
             "client-#{client}-dir" => { :default => dir,
                 :mode => 0750,
                 :desc => "Client dir for %s" % client,
@@ -21,7 +21,7 @@ Puppet::Reports.register_report(:store) do
             }
         )
 
-        config.use("reportclient-#{client}")
+        config.use("reportclient-#{client}".to_sym)
     end
 
     def process

data/lib/puppet/reports/tagmail.rb

@@ -8,12 +8,12 @@ Puppet::Reports.register_report(:tagmail) do
         based on the tags in the log messages.  See the
         `UsingTags tag documentation`:trac: for more information
         on tags.
-        
+
         To use this report, you must create a ``tagmail.conf`` (in the location
         specified by ``tagmap``).  This is a simple file that maps tags to
         email addresses:  Any log messages in the report that match the specified
         tags will be sent to the specified email addresses.
-        
+
         Tags must be comma-separated, and they can be negated so that messages
         only match when they do not have that tag.  The tags are separated from
         the email addresses by a colon, and the email addresses should also
@@ -29,9 +29,9 @@ Puppet::Reports.register_report(:tagmail) do
         This will send all messages to ``me@domain.com``, and all messages from
         webservers that are not also from mailservers to ``httpadmins@domain.com``.
 
-        If you are using anti-spam controls, such as grey-listing, on your mail 
-        server you should whitelist the sending email (controlled by ``reportform`` 
-        configuration option) to ensure your email is not discarded as spam.  
+        If you are using anti-spam controls, such as grey-listing, on your mail
+        server you should whitelist the sending email (controlled by ``reportform``
+        configuration option) to ensure your email is not discarded as spam.
         "
 
 
@@ -65,19 +65,19 @@ Puppet::Reports.register_report(:tagmail) do
                 reports << [emails, messages.collect { |m| m.to_report }.join("\n")]
             end
         end
-        
+
         return reports
     end
-    
+
     # Load the config file
     def parse(text)
         taglists = []
         text.split("\n").each do |line|
             taglist = emails = nil
             case line.chomp
-            when /^\s*#/: next
-            when /^\s*$/: next
-            when /^\s*(.+)\s*:\s*(.+)\s*$/:
+            when /^\s*#/; next
+            when /^\s*$/; next
+            when /^\s*(.+)\s*:\s*(.+)\s*$/
                 taglist = $1
                 emails = $2.sub(/#.*$/,'')
             else
@@ -91,8 +91,8 @@ Puppet::Reports.register_report(:tagmail) do
                     raise ArgumentError, "Invalid tag %s" % tag.inspect
                 end
                 case tag
-                when /^\w+/: pos << tag
-                when /^!\w+/: neg << tag.sub("!", '')
+                when /^\w+/; pos << tag
+                when /^!\w+/; neg << tag.sub("!", '')
                 else
                     raise Puppet::Error, "Invalid tag '%s'" % tag
                 end
@@ -114,13 +114,13 @@ Puppet::Reports.register_report(:tagmail) do
         end
 
         taglists = parse(File.read(Puppet[:tagmap]))
-        
+
         # Now find any appropriately tagged messages.
         reports = match(taglists)
 
         send(reports)
     end
-    
+
     # Send the email reports.
     def send(reports)
         pid = fork do
@@ -136,7 +136,7 @@ Puppet::Reports.register_report(:tagmail) do
                               p.puts "Date: " + Time.now.rfc2822
                               p.puts
                               p.puts messages
-                            end 
+                            end
                         end
                     end
                 rescue => detail

data/lib/puppet/resource.rb

@@ -0,0 +1,265 @@
+require 'puppet'
+require 'puppet/util/tagging'
+require 'puppet/resource/reference'
+require 'puppet/util/json'
+
+# The simplest resource class.  Eventually it will function as the
+# base class for all resource-like behaviour.
+class Puppet::Resource
+    include Puppet::Util::Tagging
+    extend Puppet::Util::Json
+    include Enumerable
+    attr_accessor :file, :line, :catalog, :exported, :virtual
+    attr_writer :type, :title
+
+    ATTRIBUTES = [:file, :line, :exported]
+
+    def self.from_json(json)
+        raise ArgumentError, "No resource type provided in json data" unless type = json['type']
+        raise ArgumentError, "No resource title provided in json data" unless title = json['title']
+
+        resource = new(type, title)
+
+        if params = json['parameters']
+            params.each { |param, value| resource[param] = value }
+        end
+
+        if tags = json['tags']
+            tags.each { |tag| resource.tag(tag) }
+        end
+
+        ATTRIBUTES.each do |a|
+            if value = json[a.to_s]
+                resource.send(a.to_s + "=", value)
+            end
+        end
+
+        resource.exported ||= false
+
+        resource
+    end
+
+    def to_json(*args)
+        raise "Cannot convert to JSON unless the 'json' library is installed" unless Puppet.features.json?
+
+        data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
+            next hash unless value = self.send(param)
+            hash[param.to_s] = value
+            hash
+        end
+
+        data["exported"] ||= false
+
+        params = self.to_hash.inject({}) do |hash, ary|
+            param, value = ary
+
+            # Don't duplicate the title as the namevar
+            next hash if param == namevar and value == title
+            value = [value] unless value.is_a?(Array)
+            hash[param] = value
+            hash
+        end
+
+        unless params.empty?
+            data["parameters"] = params
+        end
+
+        res = {
+            'json_class' => self.class.name,
+            'data' => data
+        }
+        res.to_json(*args)
+    end
+
+    # Proxy these methods to the parameters hash.  It's likely they'll
+    # be overridden at some point, but this works for now.
+    %w{has_key? keys length delete empty? <<}.each do |method|
+        define_method(method) do |*args|
+            @parameters.send(method, *args)
+        end
+    end
+
+    # Set a given parameter.  Converts all passed names
+    # to lower-case symbols.
+    def []=(param, value)
+        @parameters[parameter_name(param)] = value
+    end
+
+    # Return a given parameter's value.  Converts all passed names
+    # to lower-case symbols.
+    def [](param)
+        @parameters[parameter_name(param)]
+    end
+
+    # Compatibility method.
+    def builtin?
+        builtin_type?
+    end
+
+    # Is this a builtin resource type?
+    def builtin_type?
+        @reference.builtin_type?
+    end
+
+    # Iterate over each param/value pair, as required for Enumerable.
+    def each
+        @parameters.each { |p,v| yield p, v }
+    end
+
+    %w{exported virtual}.each do |m|
+        define_method(m+"?") do
+            self.send(m)
+        end
+    end
+
+    # Create our resource.
+    def initialize(type, title, parameters = {})
+        @reference = Puppet::Resource::Reference.new(type, title)
+        @parameters = {}
+
+        parameters.each do |param, value|
+            self[param] = value
+        end
+
+        tag(@reference.type)
+        tag(@reference.title) if valid_tag?(@reference.title)
+    end
+
+    # Provide a reference to our resource in the canonical form.
+    def ref
+        @reference.to_s
+    end
+
+    # Get our title information from the reference, since it will canonize it for us.
+    def title
+        @reference.title
+    end
+
+    # Get our type information from the reference, since it will canonize it for us.
+    def type
+        @reference.type
+    end
+
+    # Produce a simple hash of our parameters.
+    def to_hash
+        result = @parameters.dup
+        unless result.include?(namevar)
+            result[namevar] = title
+        end
+        result
+    end
+
+    def to_s
+        return ref
+    end
+
+    # Convert our resource to Puppet code.
+    def to_manifest
+        "%s { '%s':\n%s\n}" % [self.type.to_s.downcase, self.title,
+             @parameters.collect { |p, v|
+                 if v.is_a? Array
+                     "    #{p} => [\'#{v.join("','")}\']"
+                 else
+                     "    #{p} => \'#{v}\'"
+                 end
+             }.join(",\n")
+            ]
+    end
+
+    def to_ref
+        ref
+    end
+
+    # Convert our resource to a RAL resource instance.  Creates component
+    # instances for resource types that don't exist.
+    def to_ral
+        if typeklass = Puppet::Type.type(self.type)
+            return typeklass.new(self)
+        else
+            return Puppet::Type::Component.new(self)
+        end
+    end
+
+    # Translate our object to a backward-compatible transportable object.
+    def to_trans
+        if @reference.builtin_type?
+            result = to_transobject
+        else
+            result = to_transbucket
+        end
+
+        result.file = self.file
+        result.line = self.line
+
+        return result
+    end
+
+    # Create an old-style TransObject instance, for builtin resource types.
+    def to_transobject
+        # Now convert to a transobject
+        result = Puppet::TransObject.new(@reference.title, @reference.type)
+        to_hash.each do |p, v|
+            if v.is_a?(Puppet::Resource::Reference)
+                v = v.to_trans_ref
+            elsif v.is_a?(Array)
+                v = v.collect { |av|
+                    if av.is_a?(Puppet::Resource::Reference)
+                        av = av.to_trans_ref
+                    end
+                    av
+                }
+            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
+
+        result.tags = self.tags
+
+        return result
+    end
+
+    private
+
+    # Produce a canonical method name.
+    def parameter_name(param)
+        param = param.to_s.downcase.to_sym
+        if param == :name and n = namevar()
+            param = namevar
+        end
+        param
+    end
+
+    # The namevar for our resource type. If the type doesn't exist,
+    # always use :name.
+    def namevar
+        if t = resource_type
+            t.namevar
+        else
+            :name
+        end
+    end
+
+    # Retrieve the resource type.
+    def resource_type
+        Puppet::Type.type(type)
+    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.
+        return bucket
+    end
+end