puppet 0.24.9 → 0.25.0

data/lib/puppet/external/event-loop/signal-system.rb

@@ -20,86 +20,86 @@
 require "puppet/external/event-loop/better-definers"
 
 module SignalEmitterModule
-  def self.extended (object)
-    if object.kind_of? Module and not object < SignalEmitter
-      if object.respond_to? :fcall
-        # This is the way to call private methods
-        # in Ruby 1.9 as of November 16.
-        object.fcall :include, SignalEmitter
-      else
-        object.__send__ :include, SignalEmitter
-      end
-    end
-  end
-
-  def define_signal (name, slot=:before, &body)
-    # Can't use `define_method' and take a block pre-1.9.
-    class_eval %{ def on_#{name} &block
+    def self.extended (object)
+        if object.kind_of? Module and not object < SignalEmitter
+            if object.respond_to? :fcall
+                # This is the way to call private methods
+                # in Ruby 1.9 as of November 16.
+                object.fcall :include, SignalEmitter
+            else
+                object.__send__ :include, SignalEmitter
+            end
+        end
+    end
+
+    def define_signal (name, slot=:before, &body)
+        # Can't use `define_method' and take a block pre-1.9.
+        class_eval %{ def on_#{name} &block
                     add_signal_handler(:#{name}, &block) end }
-    define_signal_handler(name, :before, &lambda {|*a|})
-    define_signal_handler(name, :after, &lambda {|*a|})
-    define_signal_handler(name, slot, &body) if block_given?
-  end
-
-  def define_signals (*names, &body)
-    names.each { |x| define_signal(x, &body) }
-  end
-
-  def define_signal_handler (name, slot=:before, &body)
-    case slot
-    when :before
-      define_protected_method "handle_#{name}", &body
-    when :after
-      define_protected_method "after_handle_#{name}", &body
-    else
-      raise ArgumentError, "invalid slot `#{slot.inspect}'; " +
-        "should be `:before' or `:after'", caller(1)
-    end
-  end
+        define_signal_handler(name, :before, &lambda {|*a|})
+        define_signal_handler(name, :after, &lambda {|*a|})
+        define_signal_handler(name, slot, &body) if block_given?
+    end
+
+    def define_signals (*names, &body)
+        names.each { |x| define_signal(x, &body) }
+    end
+
+    def define_signal_handler (name, slot=:before, &body)
+        case slot
+        when :before
+            define_protected_method "handle_#{name}", &body
+        when :after
+            define_protected_method "after_handle_#{name}", &body
+        else
+            raise ArgumentError, "invalid slot `#{slot.inspect}'; " +
+                "should be `:before' or `:after'", caller(1)
+        end
+    end
 end
 
 # This is an old name for the same thing.
 SignalEmitterClass = SignalEmitterModule
 
 module SignalEmitter
-  def self.included (includer)
-    if not includer.kind_of? SignalEmitterClass
-      includer.extend SignalEmitterClass
-    end
-  end
-
-  def __maybe_initialize_signal_emitter
-    @signal_handlers ||= Hash.new { |h, k| h[k] = Array.new }
-    @allow_dynamic_signals ||= false
-  end
-
-  define_accessors :allow_dynamic_signals?
-
-  def add_signal_handler (name, &handler)
-    __maybe_initialize_signal_emitter
-    @signal_handlers[name] << handler
-    return handler
-  end
-
-  define_soft_aliases [:on, :on_signal] => :add_signal_handler
-
-  def remove_signal_handler (name, handler)
-    __maybe_initialize_signal_emitter
-    @signal_handlers[name].delete(handler)
-  end
-
-  def __signal__ (name, *args, &block)
-    __maybe_initialize_signal_emitter
-    respond_to? "on_#{name}" or allow_dynamic_signals? or
-      fail "undefined signal `#{name}' for #{self}:#{self.class}"
-    __send__("handle_#{name}", *args, &block) if
-      respond_to? "handle_#{name}"
-    @signal_handlers[name].each { |x| x.call(*args, &block) }
-    __send__("after_handle_#{name}", *args, &block) if
-      respond_to? "after_handle_#{name}"
-  end
-
-  define_soft_alias :signal => :__signal__
+    def self.included (includer)
+        if not includer.kind_of? SignalEmitterClass
+            includer.extend SignalEmitterClass
+        end
+    end
+
+    def __maybe_initialize_signal_emitter
+        @signal_handlers ||= Hash.new { |h, k| h[k] = Array.new }
+        @allow_dynamic_signals ||= false
+    end
+
+    define_accessors :allow_dynamic_signals?
+
+    def add_signal_handler (name, &handler)
+        __maybe_initialize_signal_emitter
+        @signal_handlers[name] << handler
+        return handler
+    end
+
+    define_soft_aliases [:on, :on_signal] => :add_signal_handler
+
+    def remove_signal_handler (name, handler)
+        __maybe_initialize_signal_emitter
+        @signal_handlers[name].delete(handler)
+    end
+
+    def __signal__ (name, *args, &block)
+        __maybe_initialize_signal_emitter
+        respond_to? "on_#{name}" or allow_dynamic_signals? or
+        fail "undefined signal `#{name}' for #{self}:#{self.class}"
+        __send__("handle_#{name}", *args, &block) if
+            respond_to? "handle_#{name}"
+        @signal_handlers[name].each { |x| x.call(*args, &block) }
+        __send__("after_handle_#{name}", *args, &block) if
+            respond_to? "after_handle_#{name}"
+    end
+
+    define_soft_alias :signal => :__signal__
 end
 
 # This module is indended to be a convenience mixin to be used by
@@ -113,108 +113,108 @@ end
 # XXX: This has not seen much use, and I'd like to provide a
 #      better solution for the problem in the future.
 module SignalObserver
-  def __maybe_initialize_signal_observer
-    @observed_signals ||= Hash.new do |signals, object|
-      signals[object] = Hash.new do |handlers, name|
-        handlers[name] = Array.new
-      end
-    end
-  end
-
-  def observe_signal (subject, name, &handler)
-    __maybe_initialize_signal_observer
-    @observed_signals[subject][name] << handler
-    subject.add_signal_handler(name, &handler)
-  end
-
-  def map_signals (source, pairs={})
-    pairs.each do |src_name, dst_name|
-      observe_signal(source, src_name) do |*args|
-        __signal__(dst_name, *args)
-      end
-    end
-  end
-
-  def absorb_signals (subject, *names)
-    names.each do |name|
-      observe_signal(subject, name) do |*args|
-        __signal__(name, *args)
-      end
-    end
-  end
-
-  define_soft_aliases \
-    :map_signal    => :map_signals,
-    :absorb_signal => :absorb_signals
-
-  def ignore_signal (subject, name)
-    __maybe_initialize_signal_observer
-    __ignore_signal_1(subject, name)
-    @observed_signals.delete(subject) if
-      @observed_signals[subject].empty?
-  end
-
-  def ignore_signals (subject, *names)
-    __maybe_initialize_signal_observer
-    names = @observed_signals[subject] if names.empty?
-    names.each { |x| __ignore_signal_1(subject, x) }
-  end
-
- private
-
-  def __ignore_signal_1(subject, name)
-    @observed_signals[subject][name].each do |handler|
-      subject.remove_signal_handler(name, handler) end
-    @observed_signals[subject].delete(name)
-  end
-end
+    def __maybe_initialize_signal_observer
+        @observed_signals ||= Hash.new do |signals, object|
+            signals[object] = Hash.new do |handlers, name|
+                handlers[name] = Array.new
+            end
+        end
+    end
 
-if __FILE__ == $0
-  require "test/unit"
-  class SignalEmitterTest < Test::Unit::TestCase
-    class X
-      include SignalEmitter
-      define_signal :foo
+    def observe_signal (subject, name, &handler)
+        __maybe_initialize_signal_observer
+        @observed_signals[subject][name] << handler
+        subject.add_signal_handler(name, &handler)
     end
 
-    def setup
-      @x = X.new
+    def map_signals (source, pairs={})
+        pairs.each do |src_name, dst_name|
+            observe_signal(source, src_name) do |*args|
+                __signal__(dst_name, *args)
+            end
+        end
     end
 
-    def test_on_signal
-      moomin = 0
-      @x.on_signal(:foo) { moomin = 1 }
-      @x.signal :foo
-      assert moomin == 1
+    def absorb_signals (subject, *names)
+        names.each do |name|
+            observe_signal(subject, name) do |*args|
+                __signal__(name, *args)
+            end
+        end
     end
 
-    def test_on_foo
-      moomin = 0
-      @x.on_foo { moomin = 1 }
-      @x.signal :foo
-      assert moomin == 1
+    define_soft_aliases \
+        :map_signal    => :map_signals,
+        :absorb_signal => :absorb_signals
+
+    def ignore_signal (subject, name)
+        __maybe_initialize_signal_observer
+        __ignore_signal_1(subject, name)
+        @observed_signals.delete(subject) if
+            @observed_signals[subject].empty?
     end
 
-    def test_multiple_on_signal
-      moomin = 0
-      @x.on_signal(:foo) { moomin += 1 }
-      @x.on_signal(:foo) { moomin += 2 }
-      @x.on_signal(:foo) { moomin += 4 }
-      @x.on_signal(:foo) { moomin += 8 }
-      @x.signal :foo
-      assert moomin == 15
+    def ignore_signals (subject, *names)
+        __maybe_initialize_signal_observer
+        names = @observed_signals[subject] if names.empty?
+        names.each { |x| __ignore_signal_1(subject, x) }
     end
 
-    def test_multiple_on_foo
-      moomin = 0
-      @x.on_foo { moomin += 1 }
-      @x.on_foo { moomin += 2 }
-      @x.on_foo { moomin += 4 }
-      @x.on_foo { moomin += 8 }
-      @x.signal :foo
-      assert moomin == 15
+  private
+
+    def __ignore_signal_1(subject, name)
+        @observed_signals[subject][name].each do |handler|
+            subject.remove_signal_handler(name, handler) end
+        @observed_signals[subject].delete(name)
+    end
+end
+
+if __FILE__ == $0
+    require "test/unit"
+    class SignalEmitterTest < Test::Unit::TestCase
+        class X
+            include SignalEmitter
+            define_signal :foo
+        end
+
+        def setup
+            @x = X.new
+        end
+
+        def test_on_signal
+            moomin = 0
+            @x.on_signal(:foo) { moomin = 1 }
+            @x.signal :foo
+            assert moomin == 1
+        end
+
+        def test_on_foo
+            moomin = 0
+            @x.on_foo { moomin = 1 }
+            @x.signal :foo
+            assert moomin == 1
+        end
+
+        def test_multiple_on_signal
+            moomin = 0
+            @x.on_signal(:foo) { moomin += 1 }
+            @x.on_signal(:foo) { moomin += 2 }
+            @x.on_signal(:foo) { moomin += 4 }
+            @x.on_signal(:foo) { moomin += 8 }
+            @x.signal :foo
+            assert moomin == 15
+        end
+
+        def test_multiple_on_foo
+            moomin = 0
+            @x.on_foo { moomin += 1 }
+            @x.on_foo { moomin += 2 }
+            @x.on_foo { moomin += 4 }
+            @x.on_foo { moomin += 8 }
+            @x.signal :foo
+            assert moomin == 15
+        end
     end
-  end
 end
 
 ## application-signals.rb ends here.

data/lib/puppet/external/lock.rb

@@ -36,7 +36,7 @@ class File
         flush
         flock(LOCK_UN)
     end
-  
+
     # Get a shared (i.e., read) lock on the file, and yield to the block.
     # If the lock is not available, wait for it without blocking other ruby
     # threads.

data/lib/puppet/external/nagios.rb

@@ -27,24 +27,24 @@ module Nagios
         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
+    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

@@ -231,9 +231,9 @@ class Nagios::Base
 
     # This is probably a bad idea.
     def name=(value)
-        unless self.class.namevar.to_s == "name" 
-            send(self.class.namevar.to_s + "=", value) 
-        end    
+        unless self.class.namevar.to_s == "name"
+            send(self.class.namevar.to_s + "=", value)
+        end
     end
 
     def namevar

data/lib/puppet/external/nagios/grammar.ry

@@ -0,0 +1,185 @@
+# vim: syntax=ruby
+class Nagios::Parser
+
+token DEFINE NAME STRING PARAM LCURLY RCURLY VALUE RETURN COMMENT INLINECOMMENT
+
+rule
+decls: decl { return val[0] if val[0] }
+    | decls decl {
+        if val[1].nil?
+            result = val[0]
+        else
+            if val[0].nil?
+                result = val[1]
+            else
+                result = [ val[0], val[1] ].flatten
+            end
+        end
+    }
+    ;
+
+decl: object { result = [val[0]] }
+    | RETURN { result = nil }
+    | comment
+    ;
+
+comment: COMMENT RETURN { result = nil }
+    ;
+
+object: DEFINE NAME LCURLY RETURN vars RCURLY {
+        result = Nagios::Base.create(val[1],val[4])
+    }
+    ;
+
+vars: var
+    | vars var {
+        val[1].each {|p,v|
+            val[0][p] = v
+        }
+        result = val[0]
+    }
+    ;
+
+var: PARAM VALUE icomment returns { result = {val[0],val[1]} }
+    ;
+
+returns:      RETURN
+            | returns RETURN
+            ;
+
+icomment: # nothing
+    | INLINECOMMENT
+    ;
+
+end
+
+----inner
+
+class ::Nagios::Parser::SyntaxError < RuntimeError; end
+
+def parse(src)
+    @src = src
+
+    # state variables
+    @invar = false
+    @inobject = false
+    @done = false
+
+    @line = 0
+    @yydebug = true
+
+    do_parse
+end
+
+# The lexer.  Very simple.
+def token
+    @src.sub!(/\A\n/,'')
+    if $&
+        @line += 1
+        return [ :RETURN, "\n" ]
+    end
+
+    if @done
+        return nil
+    end
+    yytext = String.new
+
+
+    # remove comments from this line
+    @src.sub!(/\A[ \t]*;.*\n/,"\n")
+    if $&
+        return [:INLINECOMMENT, ""]
+    end
+
+    @src.sub!(/\A#.*\n/,"\n")
+    if $&
+        return [:COMMENT, ""]
+    end
+
+    @src.sub!(/#.*/,'')
+
+    if @src.length == 0
+        @done = true
+        return [false, '$']
+    end
+
+    if @invar
+        @src.sub!(/\A[ \t]+/,'')
+        @src.sub!(/\A([^;\n]+)(\n|;)/,'\2')
+        if $1
+            yytext += $1
+        end
+        @invar = false
+        return [:VALUE, yytext]
+    else
+        @src.sub!(/\A[\t ]*(\S+)([\t ]*|$)/,'')
+        if $1
+            yytext = $1
+            case yytext
+            when 'define'
+                #puts "got define"
+                return [:DEFINE, yytext]
+            when '{'
+                #puts "got {"
+                @inobject = true
+                return [:LCURLY, yytext]
+            else
+                unless @inobject
+                    #puts "got type: #{yytext}"
+                    if yytext =~ /\W/
+                        giveback = yytext.dup
+                        giveback.sub!(/^\w+/,'')
+                        #puts "giveback " + giveback
+                        #puts "yytext " + yytext
+                        yytext.sub!(/\W.*$/,'')
+                        #puts "yytext " + yytext
+                        #puts "all [#{giveback} #{yytext} #{orig}]"
+                        @src = giveback + @src
+                    end
+                    return [:NAME, yytext]
+                else
+                    if yytext == '}'
+                        #puts "got closure: #{yytext}"
+                        @inobject = false
+                        return [:RCURLY, '}']
+                    end
+
+                    unless @invar
+                        @invar = true
+                        return [:PARAM, $1]
+                    else
+                    end
+                end
+            end
+        end
+    end
+end
+
+def next_token
+    token
+end
+
+def yydebug
+    1
+end
+
+def yywrap
+    0
+end
+
+def on_error(token, value, vstack )
+    msg = ""
+    unless value.nil?
+        msg = "line #{@line}: syntax error at '#{value}'"
+    else
+        msg = "line #{@line}: syntax error at '#{token}'"
+    end
+    unless @src.size > 0
+        msg = "line #{@line}: Unexpected end of file"
+    end
+    if token == '$end'.intern
+        puts "okay, this is silly"
+    else
+        raise ::Nagios::Parser::SyntaxError, msg
+    end
+end