puppet 0.24.1 → 0.24.2

data/ext/logcheck/puppet

@@ -13,3 +13,10 @@
 ^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Caught (TERM|INT); shutting down$
 ^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Shutting down$
 ^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Restarting with .*$
+^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Starting catalog run$
+^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Finished catalog run in [.0-9]+ seconds$
+^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Loading fact .*$
+^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Ignoring cache$
+^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Ignoring --listen on onetime run$
+^\w{3} [ :0-9]{11} [._[:alnum:]-]+ puppetd\[[0-9]+\]: Retrieving plugins$
+

data/ext/puppet-test

@@ -53,6 +53,9 @@
 # list::
 #   List all available tests.
 #
+# pause::
+#  Pause before starting test (useful for testing with dtrace).
+#
 # repeat::
 #  How many times to perform the test.
 #
@@ -88,7 +91,7 @@
 # Do an initial trap, so that cancels don't get a stack trace.
 trap(:INT) do
     $stderr.puts "Cancelling startup"
-    exit(0)
+    exit(1)
 end
 
 require 'puppet'
@@ -165,6 +168,12 @@ class Suite
         puts "Running %s %s test" % [@name, test]
         prepare()
 
+        if $options[:pause]
+            puts "Hit any key to continue"
+            $stdin.readline
+            puts "Continuing with test"
+        end
+
         if $options[:fork] > 0
             @forking = true
             $options[:fork].times {
@@ -200,6 +209,17 @@ class Suite
     end
 end
 
+Suite.new :parser, "Manifest parsing" do
+    def prepare
+    end
+
+    newtest :parse, "Parsed files" do
+        @parser = Puppet::Parser::Parser.new(:environment => Puppet[:environment])
+        @parser.file = Puppet[:manifest]
+        @parser.parse
+    end
+end
+
 Suite.new :catalog, "Catalog handling" do
     def prepare
         $args[:cache] = false
@@ -325,12 +345,13 @@ end
 
 $cmdargs = [
 	[ "--compile",    "-c",			GetoptLong::NO_ARGUMENT ],
-	[ "--describe",  "-D",			GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--describe",     			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--retrieve",  "-R",			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--fork",          			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--fqdn",      "-F",			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--suite",     "-s",			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--test",      "-t",			GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--pause",	 "-p",			GetoptLong::NO_ARGUMENT ],
 	[ "--repeat",    "-r",			GetoptLong::REQUIRED_ARGUMENT ],
 	[ "--debug",	 "-d",			GetoptLong::NO_ARGUMENT ],
 	[ "--help",		 "-h",			GetoptLong::NO_ARGUMENT ],
@@ -340,14 +361,14 @@ $cmdargs = [
 ]
 
 # Add all of the config parameters as valid $options.
-Puppet.config.addargs($cmdargs)
+Puppet.settings.addargs($cmdargs)
 Puppet::Util::Log.newdestination(:console)
 
 result = GetoptLong.new(*$cmdargs)
 
 $args = {}
 
-$options = {:repeat => 1, :fork => 0}
+$options = {:repeat => 1, :fork => 0, :pause => false}
 
 begin
     explicit_waitforcert = false
@@ -399,6 +420,8 @@ begin
                 $options[:test] = arg.intern
             when "--file"
                 $options[:file] = arg
+            when "--pause"
+                $options[:pause] = true
             when "--list"
                 Suite.suites.sort { |a,b| a.to_s <=> b.to_s }.each do |suite_name|
                     suite = Suite[suite_name]
@@ -407,7 +430,7 @@ begin
                 end
                 exit(0)
             else
-                Puppet.config.handlearg(opt, arg)
+                Puppet.settings.handlearg(opt, arg)
         end
     }
 rescue GetoptLong::InvalidOption => detail

data/lib/puppet.rb

@@ -25,7 +25,7 @@ require 'puppet/util/suidmanager'
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
-    PUPPETVERSION = '0.24.1'
+    PUPPETVERSION = '0.24.2'
 
     def Puppet.version
         return PUPPETVERSION
@@ -423,6 +423,7 @@ module Puppet
 end
 
 require 'puppet/type'
+require 'puppet/network'
 require 'puppet/module'
 require 'puppet/util/storage'
 require 'puppet/parser/interpreter'

data/lib/puppet/defaults.rb

@@ -66,7 +66,11 @@ module Puppet
             :owner => "root",
             :desc => "Where SSL certificates are kept."
         },
-        :rundir => { :default => rundir,
+        :rundir => { 
+            :default => rundir,
+            :mode => 01777,
+            :owner => "$user",
+            :group => "$group",
             :desc => "Where Puppet PID files are kept."
         },
         :genconfig => [false,
@@ -136,8 +140,6 @@ module Puppet
         :show_diff => [false, "Whether to print a contextual diff when files are being replaced.  The diff
             is printed on stdout, so this option is meaningless unless you are running Puppet interactively.
             This feature currently requires the ``diff/lcs`` Ruby library."],
-        :yamldir => {:default => "$vardir/yaml", :owner => "$user", :group => "$user", :mode => "750",
-            :desc => "The directory in which YAML data is stored, usually in a subdirectory."},
         :daemonize => { :default => true,
             :desc => "Send the process into the background.  This is the default.",
             :short => "D"
@@ -228,7 +230,7 @@ module Puppet
             :owner => "$user",
             :group => "$group",
             :mode => 0664,
-            :desc => "The certificate revocation list (CRL) for the CA. Set this to 'none' if you do not want to use a CRL."
+            :desc => "The certificate revocation list (CRL) for the CA. Set this to 'false' if you do not want to use a CRL."
         },
         :caprivatedir => { :default => "$cadir/private",
             :owner => "$user",
@@ -305,7 +307,7 @@ module Puppet
         :manifest => ["$manifestdir/site.pp",
             "The entry-point manifest for puppetmasterd."],
         :code => ["", "Code to parse directly.  This is essentially only used
-            by ``puppet`, and should only be set if you're writing your own Puppet
+            by ``puppet``, and should only be set if you're writing your own Puppet
             executable"],
         :masterlog => { :default => "$logdir/puppetmaster.log",
             :owner => "$user",
@@ -668,5 +670,10 @@ module Puppet
         :rrdinterval => ["$runinterval", "How often RRD should expect data.
             This should match how often the hosts report back to the server."]
     )
+
+    Puppet.setdefaults(:yaml,
+        :yamldir => {:default => "$vardir/yaml", :owner => "$user", :group => "$user", :mode => "750",
+            :desc => "The directory in which YAML data is stored, usually in a subdirectory."}
+    )
 end
 

data/lib/puppet/dsl.rb

@@ -46,58 +46,56 @@
 # 
 # apply
 
-module Puppet
-    # Provide the actual commands for acting like a language.
-    module DSL
-        def aspect(name, options = {}, &block)
-            Puppet::Aspect.new(name, options, &block)
-        end
+require 'puppet'
 
-        def acquire(*names)
-            names.each do |name|
-                if aspect = Puppet::Aspect[name]
-                    unless aspect.evaluated?
-                        aspect.evaluate
-                    end
-                else
-                    raise "Could not find aspect %s" % name
+# Provide the actual commands for acting like a language.
+module Puppet::DSL
+    def aspect(name, options = {}, &block)
+        Puppet::DSL::Aspect.new(name, options, &block)
+    end
+
+    def acquire(*names)
+        names.each do |name|
+            if aspect = Puppet::DSL::Aspect[name]
+                unless aspect.evaluated?
+                    aspect.evaluate
                 end
+            else
+                raise "Could not find aspect %s" % name
             end
         end
+    end
 
-        def apply
-            bucket = export()
-            catalog = bucket.to_catalog
-            catalog.apply
-        end
+    def apply
+        bucket = export()
+        catalog = bucket.to_catalog
+        catalog.apply
+    end
 
-        def export
-            objects = Puppet::Aspect.collect do |name, aspect|
-                if aspect.evaluated?
-                    aspect.export
-                end
-            end.reject { |a| a.nil? }.flatten.collect do |obj|
-                obj.to_trans
+    def export
+        objects = Puppet::DSL::Aspect.collect do |name, aspect|
+            if aspect.evaluated?
+                aspect.export
             end
-            bucket = Puppet::TransBucket.new(objects)
-            bucket.name = "top"
-            bucket.type = "class"
-
-            return bucket
+        end.reject { |a| a.nil? }.flatten.collect do |obj|
+            obj.to_trans
         end
+        bucket = Puppet::TransBucket.new(objects)
+        bucket.name = "top"
+        bucket.type = "class"
 
-        def init
-            unless Process.uid == 0
-                Puppet[:confdir] = File.expand_path("~/.puppet")
-                Puppet[:vardir] = File.expand_path("~/.puppet/var")
-            end
-            Puppet[:user] = Process.uid
-            Puppet[:group] = Process.gid
-            Puppet::Util::Log.newdestination(:console)
-            Puppet::Util::Log.level = :info
-        end
+        return bucket
+    end
 
-        private
+    def init
+        unless Process.uid == 0
+            Puppet[:confdir] = File.expand_path("~/.puppet")
+            Puppet[:vardir] = File.expand_path("~/.puppet/var")
+        end
+        Puppet[:user] = Process.uid
+        Puppet[:group] = Process.gid
+        Puppet::Util::Log.newdestination(:console)
+        Puppet::Util::Log.level = :info
     end
 
     class Aspect
@@ -224,10 +222,10 @@ module Puppet
         end
 
         def newresource(type, name, params = {})
-            if self.is_a?(Puppet::Aspect)
+            if self.is_a?(Puppet::DSL::Aspect)
                 source = self
             else
-                source = Puppet::Aspect[:main]
+                source = Puppet::DSL::Aspect[:main]
             end
             unless obj = @@objects[type][name]
                 obj = Resource.new :title => name, :type => type.name,
@@ -262,7 +260,7 @@ module Puppet
                     env = nil
                 end
                 @node.parameters = Facter.to_hash
-                @compile = Puppet::Parser::Compile.new(@node, @interp.send(:parser, env))
+                @compile = Puppet::Parser::Compiler.new(@node, @interp.send(:parser, env))
                 @scope = @compile.topscope
             end
             @scope

data/lib/puppet/external/nagios.rb

@@ -0,0 +1,50 @@
+#!/usr/local/bin/ruby -w
+
+#--------------------
+# A script to retrieve hosts from ldap and create an importable
+# cfservd file from them
+#
+# $Id: nagios.rb,v 1.3 2004/06/09 20:32:46 luke Exp $
+
+require 'digest/md5'
+#require 'ldap'
+require 'puppet/external/nagios/parser.rb'
+require 'puppet/external/nagios/base.rb'
+
+module Nagios
+    NAGIOSVERSION = '1.1'
+    # yay colors
+    PINK = ""
+    GREEN = ""
+    YELLOW = ""
+    SLATE = ""
+    ORANGE = ""
+    BLUE = ""
+    NOCOLOR = ""
+    RESET = ""
+
+    def self.version
+        NAGIOSVERSION
+    end
+
+	class Config
+		def Config.import(config)
+
+			text = String.new
+
+			File.open(config) { |file|
+				file.each { |line|
+					text += line
+				}
+			}
+			parser = Nagios::Parser.new
+			return parser.parse(text)
+		end
+		
+		def Config.each
+			Nagios::Object.objects.each { |object|
+				yield object
+			}
+		end
+	end
+end

data/lib/puppet/external/nagios/base.rb

@@ -0,0 +1,421 @@
+# The base class for all of our Nagios object types.  Everything else
+# is mostly just data.
+class Nagios::Base
+
+    class UnknownNagiosType < RuntimeError # When an unknown type is asked for by name.
+    end
+
+    include Enumerable
+
+    class << self
+        attr_accessor :parameters, :derivatives, :ocs, :name, :att
+        attr_accessor :ldapbase
+
+        attr_writer :namevar
+
+        attr_reader :superior
+    end
+
+    # Attach one class to another.
+    def self.attach(hash)
+        @attach ||= {}
+        hash.each do |n, v| @attach[n] = v end
+    end
+
+    # Convert a parameter to camelcase
+    def self.camelcase(param)
+        param.gsub(/_./) do |match|
+            match.sub(/_/,'').capitalize
+        end
+    end
+
+    # Uncamelcase a parameter.
+    def self.decamelcase(param)
+        param.gsub(/[A-Z]/) do |match|
+            "_" + match.downcase
+        end
+    end
+
+    # Create a new instance of a given class.
+    def self.create(name, args = {})
+        name = name.intern if name.is_a? String
+
+        if @types.include?(name)
+            @types[name].new(args)
+        else
+            raise UnknownNagiosType, "Unknown type %s" % name
+        end
+    end
+
+    # Yield each type in turn.
+    def self.eachtype
+        @types.each do |name, type|
+            yield [name, type]
+        end
+    end
+
+    # Create a mapping.
+    def self.map(hash)
+        @map ||= {}
+        hash.each do |n, v| @map[n] = v end
+    end
+
+    # Return a mapping (or nil) for a param
+    def self.mapping(name)
+        name = name.intern if name.is_a? String
+        if defined? @map
+            @map[name]
+        else
+            nil
+        end
+    end
+
+    # Return the namevar for the canonical name.
+    def self.namevar
+        if defined? @namevar
+            return @namevar
+        else
+            if parameter?(:name)
+                return :name
+            elsif tmp = (self.name.to_s + "_name").intern and parameter?(tmp)
+                @namevar = tmp
+                return @namevar
+            else
+                raise "Type %s has no name var" % self.name
+            end
+        end
+    end
+
+    # Create a new type.
+    def self.newtype(name, &block)
+        name = name.intern if name.is_a? String
+
+        @types ||= {}
+
+        # Create the class, with the correct name.
+        t = Class.new(self)
+        t.name = name
+
+        # Everyone gets this.  There should probably be a better way, and I
+        # should probably hack the attribute system to look things up based on
+        # this "use" setting, but, eh.
+        t.parameters = [:use]
+
+        const_set(name.to_s.capitalize,t)
+
+        # Evaluate the passed block.  This should usually define all of the work.
+        t.class_eval(&block)
+
+        @types[name] = t
+    end
+
+    # Define both the normal case and camelcase method for a parameter
+    def self.paramattr(name)
+        camel = camelcase(name)
+        param = name
+
+        [name, camel].each do |method|
+            define_method(method) do
+                @parameters[param]
+            end
+
+            define_method(method.to_s + "=") do |value|
+                @parameters[param] = value
+            end
+        end
+
+    end
+
+    # Is the specified name a valid parameter?
+    def self.parameter?(name)
+        name = name.intern if name.is_a? String
+        return @parameters.include?(name)
+    end
+
+    # Manually set the namevar
+    def self.setnamevar(name)
+        name = name.intern if name.is_a? String
+        @namevar = name
+    end
+
+    # Set the valid parameters for this class
+    def self.setparameters(*array)
+        @parameters += array
+    end
+
+    # Set the superior ldap object class.  Seems silly to include this
+    # in this class, but, eh.
+    def self.setsuperior(name)
+        @superior = name
+    end
+
+    # Parameters to suppress in output.
+    def self.suppress(name)
+        @suppress ||= []
+        @suppress << name
+    end
+
+    # Whether a given parameter is suppressed.
+    def self.suppress?(name)
+        defined? @suppress and @suppress.include?(name)
+    end
+
+    # Return our name as the string.
+    def self.to_s
+        self.name.to_s
+    end
+
+    # Return a type by name.
+    def self.type(name)
+        name = name.intern if name.is_a? String
+
+        @types[name]
+    end
+
+    # Convenience methods.
+    def [](param)
+        send(param)
+    end
+
+    # Convenience methods.
+    def []=(param,value)
+        send(param.to_s + "=", value)
+    end
+
+    # Iterate across all ofour set parameters.
+    def each
+        @parameters.each { |param,value|
+            yield(param,value)
+        }
+    end
+
+    # Initialize our object, optionally with a list of parameters.
+    def initialize(args = {})
+        @parameters = {}
+
+        args.each { |param,value|
+            self[param] = value
+        }
+    end
+
+    # Handle parameters like attributes.
+    def method_missing(mname, *args)
+        pname = mname.to_s
+        pname.sub!(/=/, '')
+
+        if self.class.parameter?(pname)
+            if pname =~ /A-Z/
+                pname = self.class.decamelcase(pname)
+            end
+            self.class.paramattr(pname)
+
+            # Now access the parameters directly, to make it at least less
+            # likely we'll end up in an infinite recursion.
+            if mname.to_s =~ /=$/
+                @parameters[pname] = *args
+            else
+                return @parameters[mname]
+            end
+        else
+            super
+        end
+    end
+
+    # Retrieve our name, through a bit of redirection.
+    def name
+        send(self.class.namevar)
+    end
+
+    # This is probably a bad idea.
+    def name=(value)
+        send(self.class.namevar.to_s + "=", value)
+    end
+
+    def namevar
+        return (self.type + "_name").intern
+    end
+
+    def parammap(param)
+        unless defined? @map
+            map = {
+                self.namevar => "cn"
+            }
+            if self.class.map
+                map.update(self.class.map)
+            end
+        end
+        if map.include?(param)
+            return map[param]
+        else
+            return "nagios-" + param.id2name.gsub(/_/,'-')
+        end
+    end
+
+    def parent
+        unless defined? self.class.attached
+            puts "Duh, you called parent on an unattached class"
+            return
+        end
+
+        klass,param = self.class.attached
+        unless @parameters.include?(param)
+            puts "Huh, no attachment param"
+            return
+        end
+        klass[@parameters[param]]
+    end
+
+    # okay, this sucks
+    # how do i get my list of ocs?
+    def to_ldif
+        base = self.class.ldapbase
+        str = self.dn + "\n"
+        ocs = Array.new
+        if self.class.ocs
+            # i'm storing an array, so i have to flatten it and stuff
+            kocs = self.class.ocs
+            ocs.push(*kocs)
+        end
+        ocs.push "top"
+        oc = self.class.to_s
+        oc.sub!(/Nagios/,'nagios')
+        oc.sub!(/::/,'')
+        ocs.push oc
+        ocs.each { |oc|
+            str += "objectclass: " + oc + "\n"
+        }
+        @parameters.each { |name,value|
+            if self.class.suppress.include?(name)
+                next
+            end
+            ldapname = self.parammap(name)
+            str += ldapname + ": " + value + "\n"
+        }
+        str += "\n"
+        str
+    end
+
+    def to_s
+        str = "define #{self.type} {\n"
+
+        self.each { |param,value|
+            str += %{\t%-30s %s\n} % [ param,
+                if value.is_a? Array
+                    value.join(",")
+                else
+                    value
+                end
+                ]
+        }
+
+        str += "}\n"
+
+        str
+    end
+
+    # The type of object we are.
+    def type
+        self.class.name
+    end
+
+	# object types
+	newtype :command do
+		setparameters :command_name, :command_line
+	end
+
+	newtype :contact do
+        setparameters :contact_name, :alias, :host_notification_period,
+			:host_notification_commands, :service_notification_period,
+			:service_notification_commands,
+			:email, :pager, :service_notification_options, :host_notification_options
+
+        setsuperior "person"
+	end
+
+	newtype :contactgroup do
+		setparameters :contactgroup_name, :alias, :members
+	end
+
+	newtype :host do
+        setparameters :host_name, :notifications_enabled, :event_handler_enabled,
+			:flap_detection_enabled, :process_perf_data, :retain_status_information,
+			:retain_nonstatus_information, :register, :use, :alias,
+			:address, :check_command, :max_check_attempts, :notification_interval,
+			:notification_period, :notification_options, :checks_enabled,
+            :failure_prediction_enabled, :parents
+
+        setsuperior "person"
+
+        map :address => "ipHostNumber"
+	end
+
+	newtype :hostextinfo do
+		auxiliary = true
+
+        setparameters :host_name, :notes_url, :icon_image, :icon_image_alt, :vrml_image,
+			"2d_coords".intern, "3d_coords".intern
+
+        setnamevar :host_name
+	end
+
+	newtype :hostgroup do
+        setparameters :hostgroup_name, :alias, :contact_groups, :members
+	end
+
+	newtype :hostgroupescalation do
+		auxiliary = true
+        setparameters :hostgroup_name, :first_notification, :last_notification,
+			:contact_groups, :notification_interval
+
+        setnamevar :hostgroup_name
+	end
+
+	newtype :service do
+        attach :host => :host_name
+        setparameters :name, :active_checks_enabled, :passive_checks_enabled,
+            :parallelize_check, :obsess_over_service, :check_freshness,
+            :notifications_enabled, :event_handler_enabled,
+            :flap_detection_enabled, :process_perf_data,
+            :retain_status_information, :retain_nonstatus_information, :register,
+            :is_volatile, :check_period, :max_check_attempts,
+            :normal_check_interval, :retry_check_interval, :contact_groups,
+            :notification_interval, :notification_period, :notification_options,
+            :service_description, :host_name, :freshness_threshold,
+            :check_command
+
+        suppress :host_name
+
+        setnamevar :service_description
+	end
+
+	newtype :servicedependency do
+        auxiliary = true
+        setparameters :host_name, :service_description, :dependent_host_name,
+			:dependent_service_description, :execution_failure_criteria,
+			:notification_failure_criteria
+
+        setnamevar :host_name
+	end
+
+    newtype :serviceescalation do
+        setparameters :host_name, :service_description, :first_notification,
+            :last_notification, :contact_groups, :notification_interval
+
+        setnamevar :host_name
+    end
+
+	newtype :serviceextinfo do
+        auxiliary = true
+
+        setparameters :host_name, :service_description, :icon_image, :icon_image_alt
+
+        setnamevar :host_name
+	end
+
+	newtype :timeperiod do
+        setparameters :timeperiod_name, :alias, :sunday, :monday, :tuesday, :wednesday,
+			:thursday, :friday, :saturday
+	end
+end
+
+# $Id$