puppet 0.18.4 → 0.22.4

data/lib/puppet/rails/external/tagging/tagging.rb

@@ -0,0 +1,12 @@
+class Tagging < ActiveRecord::Base
+  belongs_to :tag
+  belongs_to :taggable, :polymorphic => true
+
+  def self.tagged_class(taggable)
+    ActiveRecord::Base.send(:class_name_of_active_record_descendant, taggable.class).to_s
+  end
+  
+  def self.find_taggable(tagged_class, tagged_id)
+    tagged_class.constantize.find(tagged_id)
+  end
+end

data/lib/puppet/rails/fact_name.rb

@@ -0,0 +1,7 @@
+require 'puppet/rails/fact_value'
+
+class Puppet::Rails::FactName < ActiveRecord::Base
+    has_many :fact_values, :dependent => :destroy
+end
+
+# $Id: fact_name.rb 1952 2006-12-19 05:47:57Z luke $

data/lib/puppet/rails/fact_value.rb

@@ -0,0 +1,5 @@
+class Puppet::Rails::FactValue < ActiveRecord::Base
+    belongs_to :fact_name
+end
+
+# $Id: fact_value.rb 1952 2006-12-19 05:47:57Z luke $

data/lib/puppet/rails/host.rb

@@ -1,11 +1,23 @@
-require 'puppet/rails/rails_object'
+require 'puppet/rails/resource'
+require 'puppet/rails/fact_name'
+require 'puppet/rails/source_file'
+require 'puppet/util/rails/collection_merger'
+
+# Puppet::TIME_DEBUG = true
 
-#RailsObject = Puppet::Rails::RailsObject
 class Puppet::Rails::Host < ActiveRecord::Base
-    serialize :facts, Hash
-    serialize :classes, Array
+    include Puppet::Util
+    include Puppet::Util::CollectionMerger
+
+    has_many :fact_values, :through => :fact_names 
+    has_many :fact_names, :dependent => :destroy
+    belongs_to :puppet_classes
+    has_many :source_files
+    has_many :resources,
+        :include => [ :param_names, :param_values ],
+        :dependent => :destroy
 
-    has_many :rails_objects, :dependent => :delete_all
+    acts_as_taggable
 
     # If the host already exists, get rid of its objects
     def self.clean(host)
@@ -19,65 +31,102 @@ class Puppet::Rails::Host < ActiveRecord::Base
 
     # Store our host in the database.
     def self.store(hash)
-        name = hash[:host] || "localhost"
-        ip = hash[:ip] || "127.0.0.1"
-        facts = hash[:facts] || {}
-        objects = hash[:objects]
-
-        unless objects
-            raise ArgumentError, "You must pass objects"
+        unless name = hash[:name]
+            raise ArgumentError, "You must specify the hostname for storage"
         end
 
-        hostargs = {
-            :name => name,
-            :ip => ip,
-            :facts => facts,
-            :classes => objects.classes
-        }
-
-        objects = objects.flatten
+        args = {}
 
         host = nil
-        if host = clean(name)
-            [:name, :facts, :classes].each do |param|
-                unless host[param] == hostargs[param]
-                    host[param] = hostargs[param]
+        transaction do
+            #unless host = find_by_name(name)
+            seconds = Benchmark.realtime {
+                #unless host = find_by_name(name, :include => {:resources => {:param_names => :param_values}, :fact_names => :fact_values})
+                unless host = find_by_name(name, :include => {:fact_names => :fact_values})
+                #unless host = find_by_name(name)
+                    host = new(:name => name)
                 end
+            }
+            Puppet.notice("Searched for host in %0.2f seconds" % seconds) if defined?(Puppet::TIME_DEBUG)
+            if ip = hash[:facts]["ipaddress"]
+                host.ip = ip
             end
-            host.addobjects(objects)
-        else
-            host = self.new(hostargs) do |hostobj|
-                hostobj.addobjects(objects)
+
+            # Store the facts into the database.
+            host.setfacts(hash[:facts])
+
+            unless hash[:resources]
+                raise ArgumentError, "You must pass resources"
             end
-        end
 
 
-        host.save
+            seconds = Benchmark.realtime {
+                host.setresources(hash[:resources])
+            }
+            Puppet.notice("Handled resources in %0.2f seconds" % seconds) if defined?(Puppet::TIME_DEBUG)
+
+            host.last_compile = Time.now
+
+            host.save
+        end
 
         return host
     end
 
-    # Add all of our RailsObjects
-    def addobjects(objects)
-        objects.each do |tobj|
-            params = {}
-            tobj.each do |p,v| params[p] = v end
+    def tags=(tags)
+        tags.each do |tag|   
+            self.tag_with tag
+        end
+    end
+
+    # Return the value of a fact.
+    def fact(name)
+        if fv = self.fact_values.find(:first, :conditions => "fact_names.name = '#{name}'") 
+            return fv.value
+        else
+            return nil
+        end
+    end
+
+    def setfacts(facts)
+        facts = facts.dup
+        remove = []
 
-            args = {:ptype => tobj.type, :name => tobj.name}
-            [:tags, :file, :line].each do |param|
-                if val = tobj.send(param)
-                    args[param] = val
+        collection_merge :fact_names, :updates => facts, :modify => Proc.new { |fn, name, value|
+            fn.fact_values.each do |fv|
+                unless value == fv.value
+                    fv.value = value
                 end
+                break
             end
+        }, :create => Proc.new { |name, value|
+            fn = fact_names.build(:name => name)
+            fn.fact_values = [fn.fact_values.build(:value => value)]
+        }
+    end
 
-            robj = rails_objects.build(args)
-
-            robj.addparams(params)
-            if tobj.collectable
-                robj.toggle(:collectable)
-            end
+    # Set our resources.
+    def setresources(list)
+        compiled = {}
+        remove = []
+        existing = nil
+        seconds = Benchmark.realtime {
+            #existing = resources.find(:all)
+            existing = resources.find(:all, :include => {:param_names => :param_values})
+            #existing = resources
+        }
+        Puppet.notice("Searched for resources in %0.2f seconds" % seconds) if defined?(Puppet::TIME_DEBUG)
+        list.each do |resource|
+            compiled[resource.ref] = resource
         end
+
+        collection_merge :resources, :existing => existing, :updates => compiled
+    end
+
+    def update_connect_time
+        self.last_connect = Time.now
+        save
     end
 end
 
-# $Id: host.rb 1198 2006-05-15 20:19:03Z luke $
+# $Id: host.rb 2350 2007-03-24 21:24:29Z luke $

data/lib/puppet/rails/param_name.rb

@@ -0,0 +1,28 @@
+require 'puppet/util/rails/collection_merger'
+require 'puppet/rails/param_value'
+
+class Puppet::Rails::ParamName < ActiveRecord::Base
+    include Puppet::Util::CollectionMerger
+    has_many :param_values, :dependent => :destroy 
+#        def <<(value)
+#            ParamValue.with_scope(:create => {:value => value})
+#        end
+##    end
+    belongs_to :resource
+
+    def to_resourceparam(source)
+        hash = {}
+        hash[:name] = self.name.to_sym
+        hash[:source] = source
+        hash[:value] = self.param_values.find(:all).collect { |v| v.value }
+        if hash[:value].length == 1
+            hash[:value] = hash[:value].shift
+        end
+        if hash[:value].empty?
+            hash[:value] = nil
+        end
+        Puppet::Parser::Resource::Param.new hash
+    end
+end
+
+# $Id: param_name.rb 2296 2007-03-18 22:48:57Z luke $

data/lib/puppet/rails/param_value.rb

@@ -0,0 +1,5 @@
+class Puppet::Rails::ParamValue < ActiveRecord::Base
+    belongs_to :param_name
+end
+
+# $Id: param_value.rb 2296 2007-03-18 22:48:57Z luke $

data/lib/puppet/rails/puppet_class.rb

@@ -0,0 +1,9 @@
+class Puppet::Rails::PuppetClass < ActiveRecord::Base
+    has_many :resources
+    has_many :source_files
+    has_many :hosts
+
+    acts_as_taggable
+end
+
+# $Id$

data/lib/puppet/rails/resource.rb

@@ -0,0 +1,95 @@
+require 'puppet'
+require 'puppet/rails/external/tagging/init'
+require 'puppet/rails/param_name'
+require 'puppet/util/rails/collection_merger'
+
+class Puppet::Rails::Resource < ActiveRecord::Base
+    include Puppet::Util::CollectionMerger
+
+    has_many :param_values, :through => :param_names
+    has_many :param_names, :dependent => :destroy
+    belongs_to :source_file
+    belongs_to :host
+
+    acts_as_taggable
+    
+    def tags=(tags)
+        #puts "setting tags %s" % tags.inspect
+        self.tag_with(tags.join(","))
+    end
+
+    def file
+        if f = self.source_file
+            return f.filename
+        else
+            return nil
+        end
+    end
+
+    def file=(file)
+        self.source_file = Puppet::Rails::SourceFile.new(:filename => file)
+    end
+
+    def [](param)
+        return super || parameter(param)
+    end
+
+    def name
+        ref()
+    end
+
+    def parameter(param)
+        if pn = param_names.find_by_name(param)
+            if pv = pn.param_values.find(:first)
+                return pv.value
+            else
+                return nil
+            end
+        end
+    end
+
+    def parameters
+        hash = {}
+        self.param_values.find(:all).each do |pvalue|
+            pname = pvalue.param_name.name
+            hash.store(pname, pvalue.value)
+        end
+        return hash
+    end
+
+    def ref
+        "%s[%s]" % [self[:restype].capitalize, self[:title]]
+    end
+
+    # Convert our object to a resource.  Do not retain whether the object
+    # is exported, though, since that would cause it to get stripped
+    # from the configuration.
+    def to_resource(scope)
+        hash = self.attributes
+        hash["type"] = hash["restype"]
+        hash.delete("restype")
+
+        # FIXME At some point, we're going to want to retain this information
+        # for logging and auditing.
+        hash.delete("host_id")
+        hash.delete("updated_at")
+        hash.delete("source_file_id")
+        hash.delete("id")
+        hash.each do |p, v|
+            hash.delete(p) if v.nil?
+        end
+        hash[:scope] = scope
+        hash[:source] = scope.source
+        obj = Puppet::Parser::Resource.new(hash)
+        self.param_names.each do |pname|
+            obj.set(pname.to_resourceparam(scope.source))
+        end
+
+        # Store the ID, so we can check if we're re-collecting the same resource.
+        obj.rails_id = self.id
+
+        return obj
+    end
+end
+
+# $Id: resource.rb 2350 2007-03-24 21:24:29Z luke $

data/lib/puppet/rails/source_file.rb

@@ -0,0 +1,5 @@
+class Puppet::Rails::SourceFile < ActiveRecord::Base
+    has_one :host
+    has_one :puppet_class
+    has_one :resource
+end

data/lib/puppet/relationship.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-11-24.
+#  Copyright (c) 2006. All rights reserved.
+
+require 'puppet/external/gratr'
+
+# subscriptions are permanent associations determining how different
+# objects react to an event
+
+class Puppet::Relationship < GRATR::Edge
+    # Return the callback
+    def callback
+        if label
+            label[:callback]
+        else
+            nil
+        end
+    end
+    
+    # Return our event.
+    def event
+        if label
+            label[:event]
+        else
+            nil
+        end
+    end
+    
+    def initialize(source, target, label = {})
+        if label
+            unless label.is_a?(Hash)
+                raise Puppet::DevError, "The label must be a hash"
+            end
+        
+            if label[:event] and label[:event] != :NONE and ! label[:callback]
+                raise Puppet::DevError, "You must pass a callback for non-NONE events"
+            end
+        else
+            label = {}
+        end
+        
+        super(source, target, label)
+    end
+    
+    # Does the passed event match our event?  This is where the meaning
+    # of :NONE comes from. 
+    def match?(event)
+        if self.event.nil? or event == :NONE or self.event == :NONE
+            return false
+        elsif self.event == :ALL_EVENTS or event == self.event
+            return true
+        else
+            return false
+        end
+    end
+    
+    def ref
+        "%s => %s" % [source.ref, target.ref]
+    end
+end
+
+# $Id: relationship.rb 2119 2007-01-30 05:27:56Z luke $

data/lib/puppet/reports/log.rb

@@ -0,0 +1,14 @@
+require 'puppet'
+
+Puppet::Network::Handler.report.newreport(:log) do
+    desc "Send all received logs to the local log destinations.  Usually
+        the log destination is syslog."
+
+    def process
+        self.logs.each do |log|
+            Puppet::Util::Log.newmessage(log)
+        end
+    end
+end
+
+# $Id: log.rb 2367 2007-03-29 18:22:24Z luke $

data/lib/puppet/reports/rrdgraph.rb

@@ -1,20 +1,124 @@
 require 'puppet'
 
-Puppet::Server::Report.newreport(:rrdgraph) do |report|
-    time = Time.now.to_i
+Puppet::Network::Handler.report.newreport(:rrdgraph) do
+    desc "Graph all available data about hosts using the RRD library.  You
+        must have the RRD binary ruby library installed to use this report, which
+        you can get from `Tobias Oetiker's site`_.
 
-    File.open(File.join(Puppet[:rrddir],"index.html"),"w") { |of|
-        of.puts "<html><body>"
-        report.metrics.each do |name, metric|
+        .. _tobias oetiker's site: http://oss.oetiker.ch/rrdtool/pub/contrib/
+        
+        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``."
+
+    def hostdir
+        unless defined? @hostdir
+            @hostdir = File.join(Puppet[:rrddir], self.host)
+        end
+        @hostdir
+    end
+
+    def htmlfile(type, graphs, field)
+        file = File.join(hostdir, "%s.html" % type)
+        File.open(file, "w") do |of|
+            of.puts "<html><head><title>%s graphs for %s</title></head><body>" %
+                [type.capitalize, host]
+
+            graphs.each do |graph|
+                if field == :first
+                    name = graph.sub(/-\w+.png/, '').capitalize
+                else
+                    name = graph.sub(/\w+-/, '').sub(".png", '').capitalize
+                end
+                of.puts "<img src=%s><br>" % graph
+            end
+            of.puts "</body></html>"
+        end
+
+        return file
+    end
+
+    def mkhtml
+        images = Dir.entries(hostdir).find_all { |d| d =~ /\.png/ }
+
+        periodorder = %w{daily weekly monthly yearly}
+
+        periods = {}
+        types = {}
+        images.each do |n|
+            type, period = n.sub(".png", '').split("-")
+            periods[period] ||= []
+            types[type] ||= []
+            periods[period] << n
+            types[type] << n
+        end
+
+        files = []
+        # Make the period html files
+        periodorder.each do |period|
+            unless ary = periods[period]
+                raise Puppet::Error, "Could not find graphs for %s" % period
+            end
+            files << htmlfile(period, ary, :first)
+        end
+
+        # make the type html files
+        types.sort { |a,b| a[0] <=> b[0] }.each do |type, ary|
+            newary = []
+            periodorder.each do |period|
+                if graph = ary.find { |g| g.include?("-%s.png" % period) }
+                    newary << graph
+                else
+                    raise "Could not find %s-%s graph" % [type, period]
+                end
+            end
+
+            files << htmlfile(type, newary, :second)
+        end
+
+        File.open(File.join(hostdir, "index.html"), "w") do |of|
+            of.puts "<html><head><title>Report graphs for %s</title></head><body>" %
+                host
+            files.each do |file|
+                of.puts "<a href='#{File.basename(file)}'>%s</a><br/>" %
+                    File.basename(file).sub(".html",'').capitalize
+            end
+            of.puts "</body></html>"
+        end
+    end
+
+    def process(time = nil)
+        time ||= Time.now.to_i
+
+        unless File.directory?(hostdir)
+            # Some hackishness to create the dir
+            config = Puppet::Util::Config.new
+            config.setdefaults(:reports, :hostdir => [hostdir, "eh"])
+
+            # This creates the dir.
+            config.use(:reports)
+        end
+
+        self.metrics.each do |name, metric|
+            metric.basedir = hostdir
             metric.store(time)
 
             metric.graph
-
-            of.puts "<img src=%s.png><br>" % name
         end
 
-        of.puts "</body></html>"
-    }
+        unless FileTest.exists?(File.join(hostdir, "index.html"))
+            mkhtml()
+        end
+    end
 end
 
-# $Id: rrdgraph.rb 1350 2006-06-30 22:30:27Z luke $
+# $Id: rrdgraph.rb 2438 2007-04-30 18:15:01Z luke $