puppet 0.25.5 → 2.6.0

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

@@ -20,86 +20,84 @@
 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
-                    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
+  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
 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)
+    includer.extend SignalEmitterClass if not includer.kind_of? SignalEmitterClass
+  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
+    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 +111,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 __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
 
-    def observe_signal (subject, name, &handler)
-        __maybe_initialize_signal_observer
-        @observed_signals[subject][name] << handler
-        subject.add_signal_handler(name, &handler)
-    end
+  private
 
-    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 __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 absorb_signals (subject, *names)
-        names.each do |name|
-            observe_signal(subject, name) do |*args|
-                __signal__(name, *args)
-            end
-        end
+if __FILE__ == $0
+  require "test/unit"
+  class SignalEmitterTest < Test::Unit::TestCase
+    class X
+      include SignalEmitter
+      define_signal :foo
     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?
+    def setup
+      @x = X.new
     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) }
+    def test_on_signal
+      moomin = 0
+      @x.on_signal(:foo) { moomin = 1 }
+      @x.signal :foo
+      assert moomin == 1
     end
 
-  private
+    def test_on_foo
+      moomin = 0
+      @x.on_foo { moomin = 1 }
+      @x.signal :foo
+      assert moomin == 1
+    end
 
-    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)
+    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
-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
+    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
 
 ## application-signals.rb ends here.

data/lib/puppet/external/lock.rb

@@ -15,49 +15,49 @@ require 'sync'
 $reader_count = Hash.new(0)
 
 class File
-    # Get an exclusive (i.e., write) lock on the file, and yield to the block.
-    # If the lock is not available, wait for it without blocking other ruby
-    # threads.
-    def lock_exclusive
-        if Thread.list.size == 1
-            flock(LOCK_EX)
-        else
-            # ugly hack because waiting for a lock in a Ruby thread blocks the
-            # process
-            period = 0.001
-            until flock(LOCK_EX|LOCK_NB)
-                sleep period
-                period *= 2 if period < 1
-            end
-        end
-
-        yield self
-    ensure
-        flush
-        flock(LOCK_UN)
+  # Get an exclusive (i.e., write) lock on the file, and yield to the block.
+  # If the lock is not available, wait for it without blocking other ruby
+  # threads.
+  def lock_exclusive
+    if Thread.list.size == 1
+      flock(LOCK_EX)
+    else
+      # ugly hack because waiting for a lock in a Ruby thread blocks the
+      # process
+      period = 0.001
+      until flock(LOCK_EX|LOCK_NB)
+        sleep period
+        period *= 2 if period < 1
+      end
     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.
-    def lock_shared
-        if Thread.list.size == 1
-            flock(LOCK_SH)
-        else
-            # ugly hack because waiting for a lock in a Ruby thread blocks the
-            # process
-            period = 0.001
-            until flock(LOCK_SH|LOCK_NB)
-                sleep period
-                period *= 2 if period < 1
-            end
-        end
-
-        yield self
-    ensure
-        Thread.exclusive {flock(LOCK_UN) if $reader_count[self.stat.ino] == 1}
-        ## for solaris, no need to unlock here--closing does it
-        ## but this has no effect on the bug
+    yield self
+  ensure
+    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.
+  def lock_shared
+    if Thread.list.size == 1
+      flock(LOCK_SH)
+    else
+      # ugly hack because waiting for a lock in a Ruby thread blocks the
+      # process
+      period = 0.001
+      until flock(LOCK_SH|LOCK_NB)
+        sleep period
+        period *= 2 if period < 1
+      end
     end
+
+    yield self
+  ensure
+    Thread.exclusive {flock(LOCK_UN) if $reader_count[self.stat.ino] == 1}
+    ## for solaris, no need to unlock here--closing does it
+    ## but this has no effect on the bug
+  end
 end
 

data/lib/puppet/external/nagios.rb

@@ -12,39 +12,39 @@ 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
+  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
+      parser.parse(text)
     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
+    def Config.each
+      Nagios::Object.objects.each { |object|
+        yield object
+      }
     end
+  end
 end