puppet 0.24.4 → 0.24.5

data/lib/puppet/external/nagios.rb

@@ -1,4 +1,4 @@
-#!/usr/local/bin/ruby -w
+#!/usr/bin/env ruby -w
 
 #--------------------
 # A script to retrieve hosts from ldap and create an importable

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

@@ -228,7 +228,9 @@ class Nagios::Base
 
     # This is probably a bad idea.
     def name=(value)
-        send(self.class.namevar.to_s + "=", value)
+        unless self.class.namevar.to_s == "name" 
+            send(self.class.namevar.to_s + "=", value) 
+        end    
     end
 
     def namevar
@@ -318,59 +320,64 @@ class Nagios::Base
         self.class.name
     end
 
-	# object types
-	newtype :command do
-		setparameters :command_name, :command_line
-	end
+    # object types
+    newtype :command do
+        setparameters :command_name, :command_line
+    end
 
-	newtype :contact do
+    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
+            :host_notification_commands, :service_notification_period,
+            :service_notification_commands, :register, :email, :pager, 
+            :service_notification_options, :host_notification_options
 
         setsuperior "person"
-	end
+    end
 
-	newtype :contactgroup do
-		setparameters :contactgroup_name, :alias, :members
-	end
+    newtype :contactgroup do
+        setparameters :contactgroup_name, :alias, :members
+    end
 
-	newtype :host do
+    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
+            :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, :contact_groups
 
         setsuperior "person"
-
         map :address => "ipHostNumber"
-	end
-
-	newtype :hostextinfo do
-		auxiliary = true
+    end
 
+    newtype :hostextinfo do
+        auxiliary = true
         setparameters :host_name, :notes_url, :icon_image, :icon_image_alt, :vrml_image,
-			"2d_coords".intern, "3d_coords".intern
+            "2d_coords".intern, "3d_coords".intern
 
         setnamevar :host_name
-	end
+    end
 
-	newtype :hostgroup do
+    newtype :hostgroup do
         setparameters :hostgroup_name, :alias, :contact_groups, :members
-	end
+    end
+
+    newtype :hostescalation do
+        setparameters :name, :first_notification, :last_notification,
+            :notification_interval, :contact_groups,
+            :escalation_options, :register, :hostgroup_name
+        setnamevar :name
+    end              
 
-	newtype :hostgroupescalation do
-		auxiliary = true
+    newtype :hostgroupescalation do
+        auxiliary = true
         setparameters :hostgroup_name, :first_notification, :last_notification,
-			:contact_groups, :notification_interval
+            :contact_groups, :notification_interval
 
         setnamevar :hostgroup_name
-	end
+    end
 
-	newtype :service do
+    newtype :service do
         attach :host => :host_name
         setparameters :name, :active_checks_enabled, :passive_checks_enabled,
             :parallelize_check, :obsess_over_service, :check_freshness,
@@ -381,41 +388,48 @@ class Nagios::Base
             :normal_check_interval, :retry_check_interval, :contact_groups,
             :notification_interval, :notification_period, :notification_options,
             :service_description, :host_name, :freshness_threshold,
-            :check_command
+            :check_command, :hostgroup_name, :event_handler, :servicegroups, :host
 
         suppress :host_name
 
         setnamevar :service_description
-	end
+    end
 
-	newtype :servicedependency do
+    newtype :servicedependency do
         auxiliary = true
         setparameters :host_name, :service_description, :dependent_host_name,
-			:dependent_service_description, :execution_failure_criteria,
-			:notification_failure_criteria
+            :dependent_service_description, :execution_failure_criteria,
+            :notification_failure_criteria, :hostgroup_name, 
+            :dependent_hostgroup_name
 
         setnamevar :host_name
-	end
+    end
 
     newtype :serviceescalation do
         setparameters :host_name, :service_description, :first_notification,
-            :last_notification, :contact_groups, :notification_interval
+            :last_notification, :contact_groups, :notification_interval, :hostgroup_name
 
         setnamevar :host_name
     end
 
-	newtype :serviceextinfo do
+    newtype :servicegroup do
+        setparameters :servicegroup_name, :alias
+
+        setnamevar :servicegroup_name
+    end
+
+    newtype :serviceextinfo do
         auxiliary = true
 
         setparameters :host_name, :service_description, :icon_image, :icon_image_alt
 
         setnamevar :host_name
-	end
+    end
 
-	newtype :timeperiod do
-        setparameters :timeperiod_name, :alias, :sunday, :monday, :tuesday, :wednesday,
-			:thursday, :friday, :saturday
-	end
+    newtype :timeperiod do
+        setparameters :timeperiod_name, :alias, :sunday, :monday, :tuesday,
+            :wednesday, :thursday, :friday, :saturday
+    end
 end
 
 # $Id$

data/lib/puppet/file_serving/indirection_hooks.rb

@@ -12,7 +12,8 @@ module Puppet::FileServing::IndirectionHooks
     PROTOCOL_MAP = {"puppet" => :rest, "file" => :file, "puppetmounts" => :file_server}
 
     # Pick an appropriate terminus based on the protocol.
-    def select_terminus(full_uri, options = {})
+    def select_terminus(request)
+        full_uri = request.key
         # Short-circuit to :file if it's a fully-qualified path.
         return PROTOCOL_MAP["file"] if full_uri =~ /^#{::File::SEPARATOR}/
         begin
@@ -29,11 +30,12 @@ module Puppet::FileServing::IndirectionHooks
             terminus = :file_server
         end
 
+        # This is the backward-compatible module terminus.
         if terminus == :file_server and uri.path =~ %r{^/([^/]+)\b}
             modname = $1
             if modname == "modules"
                 terminus = :modules
-            elsif terminus(:modules).find_module(modname, options[:node])
+            elsif terminus(:modules).find_module(modname, request.options[:node])
                 Puppet.warning "DEPRECATION NOTICE: Found file '%s' in module without using the 'modules' mount; please prefix path with '/modules'" % uri.path
                 terminus = :modules
             end

data/lib/puppet/file_serving/metadata.rb

@@ -11,15 +11,6 @@ require 'puppet/file_serving/indirection_hooks'
 
 # A class that handles retrieving file metadata.
 class Puppet::FileServing::Metadata < Puppet::FileServing::FileBase
-    module MetadataHelper
-        include Puppet::FileServing::IndirectionHooks
-
-        def post_find(instance)
-        end
-
-        def post_search(key, options = {})
-        end
-    end
 
     include Puppet::Util::Checksums
 

data/lib/puppet/file_serving/terminus_helper.rb

@@ -8,11 +8,11 @@ require 'puppet/file_serving/fileset'
 # Define some common methods for FileServing termini.
 module Puppet::FileServing::TerminusHelper
     # Create model instances for all files in a fileset.
-    def path2instances(key, path, options = {})
-        args = [:links, :ignore, :recurse].inject({}) { |hash, param| hash[param] = options[param] if options[param]; hash }
+    def path2instances(request, path)
+        args = [:links, :ignore, :recurse].inject({}) { |hash, param| hash[param] = request.options[param] if request.options[param]; hash }
         Puppet::FileServing::Fileset.new(path, args).files.collect do |file|
-            inst = model.new(File.join(key, file), :path => path, :relative_path => file)
-            inst.links = options[:links] if options[:links]
+            inst = model.new(File.join(request.key, file), :path => path, :relative_path => file)
+            inst.links = request.options[:links] if request.options[:links]
             inst
         end
     end

data/lib/puppet/indirector.rb

@@ -9,6 +9,7 @@ module Puppet::Indirector
 
     require 'puppet/indirector/indirection'
     require 'puppet/indirector/terminus'
+    require 'puppet/indirector/envelope'
 
     # Declare that the including class indirects its methods to
     # this terminus.  The terminus name must be the name of a Puppet
@@ -20,6 +21,7 @@ module Puppet::Indirector
         # populate this class with the various new methods
         extend ClassMethods
         include InstanceMethods
+        include Puppet::Indirector::Envelope
 
         # instantiate the actual Terminus for that type and this name (:ldap, w/ args :node)
         # & hook the instantiated Terminus into this class (Node: @indirection = terminus)
@@ -28,41 +30,37 @@ module Puppet::Indirector
     end
 
     module ClassMethods   
-      attr_reader :indirection
+        attr_reader :indirection
 
-      def cache_class=(klass)
-          indirection.cache_class = klass
-      end
+        def cache_class=(klass)
+            indirection.cache_class = klass
+        end
 
-      def terminus_class=(klass)
-          indirection.terminus_class = klass
-      end
+        def terminus_class=(klass)
+            indirection.terminus_class = klass
+        end
          
-      def find(*args)
-        indirection.find(*args)
-      end
-
-      def destroy(*args)
-        indirection.destroy(*args)
-      end
+        # Expire any cached instance.
+        def expire(*args)
+            indirection.expire *args
+        end
+         
+        def find(*args)
+            indirection.find *args
+        end
 
-      def search(*args)
-        indirection.search(*args)
-      end
+        def destroy(*args)
+            indirection.destroy *args
+        end
 
-      def version(*args)
-        indirection.version(*args)
-      end
+        def search(*args)
+            indirection.search *args
+        end
     end
 
     module InstanceMethods
-      # Make it easy for the model to set versions,
-      # which are used for caching and such.
-      attr_accessor :version
-
-      # these become instance methods 
-      def save(*args)
-        self.class.indirection.save(self, *args)
-      end
+        def save(*args)
+            self.class.indirection.save self, *args
+        end
     end
 end

data/lib/puppet/indirector/catalog/compiler.rb

@@ -13,15 +13,13 @@ class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
     attr_accessor :code
 
     # Compile a node's catalog.
-    def find(key, client = nil, clientip = nil)
-        if key.is_a?(Puppet::Node)
-            node = key
-        else
-            node = find_node(key)
+    def find(request)
+        unless node = request.options[:use_node] || find_node(request.key)
+            raise ArgumentError, "Could not find node '%s'; cannot compile" % request.key
         end
 
         if catalog = compile(node)
-            return catalog.to_transportable
+            return catalog
         else
             # This shouldn't actually happen; we should either return
             # a config or raise an exception.
@@ -46,22 +44,6 @@ class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
         $0 =~ /puppetmasterd/
     end
 
-    # Return the catalog version.  Here we're returning the
-    # latest of the node, fact, or parse date.  These are the
-    # three things that go into compiling a client catalog,
-    # so changes in any of them result in changes.
-    # LAK:FIXME Note that this only works when all three sources
-    # use timestamps; once one of them moves to using real versions,
-    # the comparison stops working.
-    def version(key)
-        if node = Puppet::Node.find_by_any_name(key)
-            return [Puppet::Node.version(key).to_f, Puppet::Node::Facts.version(key).to_f, interpreter.catalog_version(node).to_f].sort[-1]
-        else
-            # This is the standard for "got nothing for ya".
-            0
-        end
-    end
-
     private
 
     # Add any extra data necessary to the node.
@@ -102,16 +84,12 @@ class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
     def find_node(key)
         # If we want to use the cert name as our key
         # LAK:FIXME This needs to be figured out somehow, but it requires the routing.
+        # This should be able to use the request, yay.
         #if Puppet[:node_name] == 'cert' and client
         #    key = client
         #end
 
-        # Note that this is reasonable, because either their node source should actually
-        # know about the node, or they should be using the ``null`` node source, which
-        # will always return data.
-        unless node = Puppet::Node.find_by_any_name(key)
-            raise Puppet::Error, "Could not find node '%s'" % key
-        end
+        return nil unless node = Puppet::Node.find(key)
 
         # Add any external data to the node.
         add_node_data(node)

data/lib/puppet/indirector/checksum/file.rb

@@ -18,8 +18,8 @@ class Puppet::Checksum::File < Puppet::Indirector::File
         path.join(File::SEPARATOR)
     end
 
-    def save(file)
-        path = File.dirname(path(file.name))
+    def save(request)
+        path = File.dirname(path(request.key))
 
         # Make the directories if necessary.
         unless FileTest.directory?(path)

data/lib/puppet/indirector/direct_file_server.rb

@@ -11,17 +11,17 @@ class Puppet::Indirector::DirectFileServer < Puppet::Indirector::Terminus
     include Puppet::Util::URIHelper
     include Puppet::FileServing::TerminusHelper
 
-    def find(key, options = {})
-        uri = key2uri(key)
+    def find(request)
+        uri = key2uri(request.key)
         return nil unless FileTest.exists?(uri.path)
-        instance = model.new(key, :path => uri.path)
-        instance.links = options[:links] if options[:links]
+        instance = model.new(request.key, :path => uri.path)
+        instance.links = request.options[:links] if request.options[:links]
         return instance
     end
 
-    def search(key, options = {})
-        uri = key2uri(key)
+    def search(request)
+        uri = key2uri(request.key)
         return nil unless FileTest.exists?(uri.path)
-        path2instances(key, uri.path, options)
+        path2instances(request, uri.path)
     end
 end

data/lib/puppet/indirector/envelope.rb

@@ -0,0 +1,13 @@
+require 'puppet/indirector'
+
+# Provide any attributes or functionality needed for indirected
+# instances.
+module Puppet::Indirector::Envelope
+    attr_accessor :expiration
+
+    def expired?
+        return false unless expiration
+        return false if expiration >= Time.now
+        return true
+    end
+end

data/lib/puppet/indirector/exec.rb

@@ -3,9 +3,9 @@ require 'puppet/util'
 
 class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     # Look for external node definitions.
-    def find(name)
+    def find(request)
         # Run the command.
-        unless output = query(name)
+        unless output = query(request.key)
             return nil
         end
 

data/lib/puppet/indirector/facts/facter.rb

@@ -56,8 +56,8 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     end
 
     # Look a host's facts up in Facter.
-    def find(key)
-        Puppet::Node::Facts.new(key, Facter.to_hash)
+    def find(request)
+        Puppet::Node::Facts.new(request.key, Facter.to_hash)
     end
 
     def save(facts)