puppet 0.16.0 → 0.18.4

data/lib/puppet/rails.rb

@@ -0,0 +1,115 @@
+# Load the appropriate libraries, or set a class indicating they aren't available
+
+require 'facter'
+require 'puppet'
+
+begin
+    require 'active_record'
+rescue LoadError => detail
+    if Facter["operatingsystem"].value == "Debian" and
+        FileTest.exists?("/usr/share/rails")
+            count = 0
+            Dir.entries("/usr/share/rails").each do |dir|
+                libdir = File.join("/usr/share/rails", dir, "lib")
+                if FileTest.exists?(libdir) and ! $:.include?(libdir)
+                    count += 1
+                    $: << libdir
+                end
+            end
+
+            if count > 0
+                retry
+            end
+    end
+end
+
+# If we couldn't find it the normal way, try using a Gem.
+unless defined? ActiveRecord
+    begin
+        require 'rubygems'
+        require_gem 'rails'
+    rescue LoadError
+        # Nothing
+    end
+end
+
+module Puppet::Rails
+    Puppet.config.setdefaults(:puppetmaster,
+        :dblocation => { :default => "$statedir/clientconfigs.sqlite3",
+            :mode => 0600,
+            :owner => "$user",
+            :group => "$group",
+            :desc => "The database cache for client configurations.  Used for
+                querying within the language."
+        },
+        :dbadapter => [ "sqlite3", "The type of database to use." ],
+        :dbname => [ "puppet", "The name of the database to use." ],
+        :dbserver => [ "puppet", "The database server for Client caching. Only
+            used when networked databases are used."],
+        :dbuser => [ "puppet", "The database user for Client caching. Only
+            used when networked databases are used."],
+        :dbpassword => [ "puppet", "The database password for Client caching. Only
+            used when networked databases are used."],
+        :railslog => {:default => "$logdir/puppetrails.log",
+            :mode => 0600,
+            :owner => "$user",
+            :group => "$group",
+            :desc => "Where Rails-specific logs are sent"
+        }
+    )
+
+    def self.clear
+        @inited = false
+    end
+
+    # Set up our database connection.  It'd be nice to have a "use" system
+    # that could make callbacks.
+    def self.init
+        unless defined? ActiveRecord::Base
+            raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails"
+        end
+
+        # This global init does not work for testing, because we remove
+        # the state dir on every test.
+        #unless (defined? @inited and @inited) or defined? Test::Unit::TestCase
+        unless (defined? @inited and @inited)
+            Puppet.config.use(:puppet)
+
+            ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
+            args = {:adapter => Puppet[:dbadapter]}
+
+            case Puppet[:dbadapter]
+            when "sqlite3":
+                args[:database] = Puppet[:dblocation]
+            when "mysql":
+                args[:host]     = Puppet[:dbserver]
+                args[:username] = Puppet[:dbuser]
+                args[:password] = Puppet[:dbpassword]
+                args[:database] = Puppet[:dbname]
+            end
+
+            ActiveRecord::Base.establish_connection(args)
+
+            @inited = true
+        end
+
+        if Puppet[:dbadapter] == "sqlite3" and ! FileTest.exists?(Puppet[:dblocation])
+            require 'puppet/rails/database'
+            begin
+                Puppet::Rails::Database.up
+            rescue => detail
+                if Puppet[:debug]
+                    puts detail.backtrace
+                end
+                raise Puppet::Error, "Could not initialize database: %s" % detail
+            end
+        end
+        Puppet.config.use(:puppetmaster)
+    end
+end
+
+if defined? ActiveRecord::Base
+    require 'puppet/rails/host'
+end
+
+# $Id: rails.rb 1205 2006-05-17 23:42:22Z luke $

data/lib/puppet/rails/database.rb

@@ -0,0 +1,40 @@
+class Puppet::Rails::Database < ActiveRecord::Migration
+    require 'sqlite3'
+
+    def self.up
+        if ActiveRecord::Migration.respond_to?(:verbose)
+            ActiveRecord::Migration.verbose = false
+        end
+
+        create_table :rails_objects do |table|
+            table.column :name, :string, :null => false
+            table.column :ptype,  :string, :null => false
+            table.column :tags, :string
+            table.column :file, :string
+            table.column :line, :integer
+            table.column :host_id, :integer
+            table.column :collectable, :boolean
+        end
+
+        create_table :rails_parameters do |table|
+            table.column :name, :string, :null => false
+            table.column :value,  :string, :null => false
+            table.column :rails_object_id,  :integer
+        end
+
+        create_table :hosts do |table|
+            table.column :name, :string, :null => false
+            table.column :ip, :string
+            table.column :facts, :string
+            table.column :connect, :date
+            table.column :success, :date
+            table.column :classes, :string
+        end
+    end
+
+    def self.down
+        drop_table :rails_objects
+        drop_table :rails_parameters
+        drop_table :hosts
+    end
+end

data/lib/puppet/rails/host.rb

@@ -0,0 +1,83 @@
+require 'puppet/rails/rails_object'
+
+#RailsObject = Puppet::Rails::RailsObject
+class Puppet::Rails::Host < ActiveRecord::Base
+    serialize :facts, Hash
+    serialize :classes, Array
+
+    has_many :rails_objects, :dependent => :delete_all
+
+    # If the host already exists, get rid of its objects
+    def self.clean(host)
+        if obj = self.find_by_name(host)
+            obj.rails_objects.clear
+            return obj
+        else
+            return nil
+        end
+    end
+
+    # 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"
+        end
+
+        hostargs = {
+            :name => name,
+            :ip => ip,
+            :facts => facts,
+            :classes => objects.classes
+        }
+
+        objects = objects.flatten
+
+        host = nil
+        if host = clean(name)
+            [:name, :facts, :classes].each do |param|
+                unless host[param] == hostargs[param]
+                    host[param] = hostargs[param]
+                end
+            end
+            host.addobjects(objects)
+        else
+            host = self.new(hostargs) do |hostobj|
+                hostobj.addobjects(objects)
+            end
+        end
+
+
+        host.save
+
+        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
+
+            args = {:ptype => tobj.type, :name => tobj.name}
+            [:tags, :file, :line].each do |param|
+                if val = tobj.send(param)
+                    args[param] = val
+                end
+            end
+
+            robj = rails_objects.build(args)
+
+            robj.addparams(params)
+            if tobj.collectable
+                robj.toggle(:collectable)
+            end
+        end
+    end
+end
+
+# $Id: host.rb 1198 2006-05-15 20:19:03Z luke $

data/lib/puppet/rails/rails_object.rb

@@ -0,0 +1,42 @@
+require 'puppet'
+require 'puppet/rails/rails_parameter'
+
+#RailsParameter = Puppet::Rails::RailsParameter
+class Puppet::Rails::RailsObject < ActiveRecord::Base
+    has_many :rails_parameters, :dependent => :delete_all
+    serialize :tags, Array
+
+    belongs_to :host
+
+    # Add a set of parameters.
+    def addparams(params)
+        params.each do |pname, pvalue|
+            rails_parameters.build(
+                :name => pname,
+                :value => pvalue
+            )
+
+            #self.rails_parameters << pobj
+        end
+    end
+
+    # Convert our object to a trans_object.  Do not retain whether the object
+    # is collectable, though, since that would cause it to get stripped
+    # from the configuration.
+    def to_trans
+        obj = Puppet::TransObject.new(name(), ptype())
+
+        [:file, :line, :tags].each do |method|
+            if val = send(method)
+                obj.send(method.to_s + "=", val)
+            end
+        end
+        rails_parameters.each do |param|
+            obj[param.name] = param.value
+        end
+
+        return obj
+    end
+end
+
+# $Id: rails_object.rb 1192 2006-05-14 02:42:21Z luke $

data/lib/puppet/rails/rails_parameter.rb

@@ -0,0 +1,5 @@
+class Puppet::Rails::RailsParameter < ActiveRecord::Base
+    belongs_to :rails_objects
+end
+
+# $Id: rails_parameter.rb 1187 2006-05-13 04:52:34Z luke $

data/lib/puppet/reports/rrdgraph.rb

@@ -0,0 +1,20 @@
+require 'puppet'
+
+Puppet::Server::Report.newreport(:rrdgraph) do |report|
+    time = Time.now.to_i
+
+    File.open(File.join(Puppet[:rrddir],"index.html"),"w") { |of|
+        of.puts "<html><body>"
+        report.metrics.each do |name, metric|
+            metric.store(time)
+
+            metric.graph
+
+            of.puts "<img src=%s.png><br>" % name
+        end
+
+        of.puts "</body></html>"
+    }
+end
+
+# $Id: rrdgraph.rb 1350 2006-06-30 22:30:27Z luke $

data/lib/puppet/reports/tagmail.rb

@@ -0,0 +1,94 @@
+require 'puppet'
+
+Puppet.config.setdefaults(:reporting,
+    :tagmap => ["$confdir/tagmail.conf",
+        "The mapping between reporting tags and email addresses."],
+    :sendmail => [%x{which sendmail 2>/dev/null}.chomp,
+        "Where to find the sendmail binary with which to send email."],
+    :reportfrom => ["report@" + [Facter["hostname"].value, Facter["domain"].value].join("."),
+        "The 'from' email address for the reports."],
+    :smtpserver => ["none",
+        "The server through which to send email reports."]
+)
+
+require 'net/smtp'
+
+Puppet::Server::Report.newreport(:tagmail) do |report|
+    unless FileTest.exists?(Puppet[:tagmap])
+        Puppet.notice "Cannot send tagmail report; no tagmap file %s" %
+            Puppet[:tagmap]
+        return
+    end
+
+    # Load the config file
+    tags = {}
+    File.readlines(Puppet[:tagmap]).each do |line|
+        taglist, emails = line.chomp.split(/\s*:\s*/)
+
+        emails = emails.split(/\s*,\s*/)
+        taglist.split(/\s*,\s*/).each do |tag|
+            tags[tag] = emails
+        end
+    end
+
+    # Now find any appropriately tagged messages.
+    reports = {}
+    tags.each do |tag, emails|
+        messages = nil
+        if tag == "all"
+            messages = report.logs
+        else
+            messages = report.logs.find_all do |log|
+                log.tagged?(tag)
+            end
+        end
+
+        if messages and ! messages.empty?
+            reports[emails] = messages.collect { |m| m.to_report }.join("\n")
+        else
+            Puppet.info "No messages to report"
+        end
+    end
+
+    # Let's fork for the sending of the email, since you never know what might
+    # happen.
+    fork do
+        if Puppet[:smtpserver] != "none"
+            begin
+                Net::SMTP.start(Puppet[:smtpserver]) do |smtp|
+                    reports.each do |emails, messages|
+                        Puppet.info "Sending report to %s" % emails.join(", ")
+                        smtp.send_message(messages, Puppet[:reportfrom], *emails)
+                    end
+                end
+            rescue => detail
+                if Puppet[:debug]
+                    puts detail.backtrace
+                end
+                raise Puppet::Error,
+                    "Could not send report emails through smtp: %s" % detail
+            end
+        elsif Puppet[:sendmail] != ""
+            begin
+                reports.each do |emails, messages|
+                    Puppet.info "Sending report to %s" % emails.join(", ")
+                    # We need to open a separate process for every set of email addresses
+                    IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
+                        p.puts "From: #{Puppet[:reportfrom]}"
+                        p.puts "Subject: Puppet Report for %s" % report.host
+
+                        p.puts messages
+                    end
+                end
+            rescue => detail
+                if Puppet[:debug]
+                    puts detail.backtrace
+                end
+                raise Puppet::Error,
+                    "Could not send report emails via sendmail: %s" % detail
+            end
+        else
+            raise Puppet::Error, "SMTP server is unset and could not find sendmail"
+        end
+    end
+end

data/lib/puppet/server.rb

@@ -27,6 +27,14 @@ module Puppet
         class Server < WEBrick::HTTPServer
             include Puppet::Daemon
 
+            Puppet.config.setdefaults(:puppetd,
+                :listen => [false, "Whether puppetd should listen for
+                    connections.  If this is true, then by default only the
+                    ``runner`` server is started, which allows remote authorized
+                    and authenticated nodes to connect and trigger ``puppetd``
+                    runs."]
+            )
+
             # Create our config object if necessary.  This works even if
             # there's no configuration file.
             def authconfig
@@ -75,6 +83,12 @@ module Puppet
                     @driver = ca
                     @secureinit = true
                     self.fqdn
+                else
+                    if hash.include?(:NoSecureInit)
+                        @secureinit = false
+                    else
+                        @secureinit = true
+                    end
                 end
 
                 unless self.readcert
@@ -104,9 +118,7 @@ module Puppet
                 # mount has to be called after the server is initialized
                 self.mount("/RPC2", Puppet::Server::Servlet, @handlers)
             end
-        end
 
-        class Server
             # the base class for the different handlers
             class Handler
                 attr_accessor :server
@@ -117,8 +129,9 @@ module Puppet
                 end
 
                 def self.handler(name)
+                    name = name.to_s.downcase
                     @subclasses.find { |h|
-                        h.name == name
+                        h.name.to_s.downcase == name
                     }
                 end
 
@@ -174,7 +187,10 @@ require 'puppet/server/master'
 require 'puppet/server/ca'
 require 'puppet/server/fileserver'
 require 'puppet/server/filebucket'
+require 'puppet/server/pelement'
+require 'puppet/server/runner'
 require 'puppet/server/logger'
+require 'puppet/server/report'
 require 'puppet/client'
 
-# $Id: server.rb 1129 2006-04-21 19:14:59Z luke $
+# $Id: server.rb 1339 2006-06-29 20:32:17Z luke $