puppet 2.7.9 → 2.7.11

data/spec/unit/util/instrumentation/listener_spec.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require 'matchers/json'
+
+require 'puppet/util/instrumentation'
+require 'puppet/util/instrumentation/listener'
+
+describe Puppet::Util::Instrumentation::Listener do
+
+  Listener = Puppet::Util::Instrumentation::Listener
+
+  before(:each) do
+    @delegate = stub 'listener', :notify => nil, :name => 'listener'
+    @listener = Listener.new(@delegate)
+    @listener.enabled = true
+  end
+
+  it "should indirect instrumentation_listener" do
+    Listener.indirection.name.should == :instrumentation_listener
+  end
+
+  it "should raise an error if delegate doesn't support notify" do
+    lambda { Listener.new(Object.new) }.should raise_error
+  end
+
+  it "should not be enabled by default" do
+    Listener.new(@delegate).should_not be_enabled
+  end
+
+  it "should delegate notification" do
+    @delegate.expects(:notify).with(:event, :start, {})
+    listener = Listener.new(@delegate)
+    listener.notify(:event, :start, {})
+  end
+
+  it "should not listen is not enabled" do
+    @listener.enabled = false
+    @listener.should_not be_listen_to(:label)
+  end
+
+  it "should listen to all label if created without pattern" do
+    @listener.should be_listen_to(:improbable_label)
+  end
+
+  it "should listen to specific string pattern" do
+    listener = Listener.new(@delegate, "specific")
+    listener.enabled = true
+    listener.should be_listen_to(:specific)
+  end
+
+  it "should not listen to non-matching string pattern" do
+    listener = Listener.new(@delegate, "specific")
+    listener.enabled = true
+    listener.should_not be_listen_to(:unspecific)
+  end
+
+  it "should listen to specific regex pattern" do
+    listener = Listener.new(@delegate, /spe.*/)
+    listener.enabled = true
+    listener.should be_listen_to(:specific_pattern)
+  end
+
+  it "should not listen to non matching regex pattern" do
+    listener = Listener.new(@delegate, /^match.*/)
+    listener.enabled = true
+    listener.should_not be_listen_to(:not_matching)
+  end
+
+  it "should delegate its name to the underlying listener" do
+    @delegate.expects(:name).returns("myname")
+    @listener.name.should == "myname"
+  end
+
+  it "should delegate data fetching to the underlying listener" do
+    @delegate.expects(:data).returns(:data)
+    @listener.data.should == {:data => :data }
+  end
+
+  describe "when serializing to pson" do
+    it "should return a pson object containing pattern, name and status" do
+      @listener.should set_json_attribute('enabled').to(true)
+      @listener.should set_json_attribute('name').to("listener")
+    end
+  end
+
+  describe "when deserializing from pson" do
+    it "should lookup the archetype listener from the instrumentation layer" do
+      Puppet::Util::Instrumentation.expects(:[]).with("listener").returns(@listener)
+      Puppet::Util::Instrumentation::Listener.from_pson({"name" => "listener"})
+    end
+
+    it "should create a new listener shell instance delegating to the archetypal listener" do
+      Puppet::Util::Instrumentation.expects(:[]).with("listener").returns(@listener)
+      @listener.stubs(:listener).returns(@delegate)
+      Puppet::Util::Instrumentation::Listener.expects(:new).with(@delegate, nil, true)
+      Puppet::Util::Instrumentation::Listener.from_pson({"name" => "listener", "enabled" => true})
+    end
+  end
+end

data/spec/unit/util/instrumentation/listeners/log_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'puppet/util/instrumentation'
+
+Puppet::Util::Instrumentation.init
+log = Puppet::Util::Instrumentation.listener(:log)
+
+describe log do
+  before(:each) do
+    @log = log.new
+  end
+
+  it "should have a notify method" do
+    @log.should respond_to(:notify)
+  end
+
+  it "should have a data method" do
+    @log.should respond_to(:data)
+  end
+
+  it "should keep data for stop event" do
+    @log.notify(:test, :stop, { :started => Time.at(123456789), :finished => Time.at(123456790)})
+    @log.data.should == {:test=>["test took 1.0"]}
+  end
+
+  it "should not keep data for start event" do
+    @log.notify(:test, :start, { :started => Time.at(123456789)})
+    @log.data.should be_empty
+  end
+
+  it "should not keep more than 20 events per label" do
+    25.times { @log.notify(:test, :stop, { :started => Time.at(123456789), :finished => Time.at(123456790)}) }
+    @log.data[:test].size.should == 20
+  end
+end

data/spec/unit/util/instrumentation/listeners/performance_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'puppet/util/instrumentation'
+
+Puppet::Util::Instrumentation.init
+performance = Puppet::Util::Instrumentation.listener(:performance)
+
+describe performance do
+  before(:each) do
+    @performance = performance.new
+  end
+
+  it "should have a notify method" do
+    @performance.should respond_to(:notify)
+  end
+
+  it "should have a data method" do
+    @performance.should respond_to(:data)
+  end
+
+  it "should keep data for stop event" do
+    @performance.notify(:test, :stop, { :started => Time.at(123456789), :finished => Time.at(123456790)})
+    @performance.data.should == {:test=>{:average=>1.0, :count=>1, :min=>1.0, :max=>1.0, :sum=>1.0}}
+  end
+
+  it "should accumulate performance statistics" do
+    @performance.notify(:test, :stop, { :started => Time.at(123456789), :finished => Time.at(123456790)})
+    @performance.notify(:test, :stop, { :started => Time.at(123456789), :finished => Time.at(123456791)})
+
+    @performance.data.should == {:test=>{:average=>1.5, :count=>2, :min=>1.0, :max=>2.0, :sum=>3.0}}
+  end
+
+  it "should not keep data for start event" do
+    @performance.notify(:test, :start, { :started => Time.at(123456789)})
+    @performance.data.should be_empty
+  end
+end

data/spec/unit/util/instrumentation_spec.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require 'puppet/util/instrumentation'
+
+describe Puppet::Util::Instrumentation do
+
+  Instrumentation = Puppet::Util::Instrumentation
+
+  after(:each) do
+    Instrumentation.clear
+  end
+
+  it "should instance-load instrumentation listeners" do
+    Instrumentation.instance_loader(:listener).should be_instance_of(Puppet::Util::Autoload)
+  end
+
+  it "should have a method for registering instrumentation listeners" do
+    Instrumentation.should respond_to(:new_listener)
+  end
+
+  it "should have a method for retrieving instrumentation listener by name" do
+    Instrumentation.should respond_to(:listener)
+  end
+
+  describe "when registering listeners" do
+    it "should evaluate the supplied block as code for a class" do
+      Instrumentation.expects(:genclass).returns(Class.new { def notify(label, event, data) ; end })
+      Instrumentation.new_listener(:testing, :label_pattern => :for_this_label, :event => :all) { }
+    end
+
+    it "should subscribe a new listener instance" do
+      Instrumentation.expects(:genclass).returns(Class.new { def notify(label, event, data) ; end })
+      Instrumentation.new_listener(:testing, :label_pattern => :for_this_label, :event => :all) { }
+      Instrumentation.listeners.size.should == 1
+      Instrumentation.listeners[0].pattern.should == "for_this_label"
+    end
+
+    it "should be possible to access listeners by name" do
+      Instrumentation.expects(:genclass).returns(Class.new { def notify(label, event, data) ; end })
+      Instrumentation.new_listener(:testing, :label_pattern => :for_this_label, :event => :all) { }
+      Instrumentation["testing"].should_not be_nil
+    end
+
+    it "should be possible to store a new listener by name" do
+      listener = stub 'listener'
+      Instrumentation["testing"] = listener
+      Instrumentation["testing"].should == listener
+    end
+
+    it "should fail if listener is already subscribed" do
+      listener = stub 'listener', :notify => nil, :name => "mylistener"
+      Instrumentation.subscribe(listener, :for_this_label, :all)
+      expect { Instrumentation.subscribe(listener, :for_this_label, :all) }.to raise_error
+    end
+
+    it 'should call #unsubscribed' do
+      listener = stub 'listener', :notify => nil, :name => "mylistener"
+
+      listener.expects(:subscribed)
+
+      Instrumentation.subscribe(listener, :for_this_label, :all)
+    end
+  end
+
+  describe "when unsubscribing listener" do
+    it "should remove it from the listeners" do
+      listener = stub 'listener', :notify => nil, :name => "mylistener"
+      Instrumentation.subscribe(listener, :for_this_label, :all)
+      Instrumentation.unsubscribe(listener)
+      Instrumentation.listeners.size.should == 0
+    end
+
+    it "should warn if the listener wasn't subscribed" do
+      listener = stub 'listener', :notify => nil, :name => "mylistener"
+      Puppet.expects(:warning)
+      Instrumentation.unsubscribe(listener)
+    end
+
+    it 'should call #unsubscribed' do
+      listener = stub 'listener', :notify => nil, :name => "mylistener"
+      Instrumentation.subscribe(listener, :for_this_label, :all)
+
+      listener.expects(:unsubscribed)
+
+      Instrumentation.unsubscribe(listener)
+    end
+  end
+
+  describe "when firing events" do
+    it "should be able to find all listeners matching a label" do
+      listener = stub 'listener', :notify => nil, :name => "mylistener"
+      Instrumentation.subscribe(listener, :for_this_label, :all)
+      Instrumentation.listeners[0].enabled = true
+
+      count = 0
+      Instrumentation.each_listener(:for_this_label) { |l| count += 1 }
+      count.should == 1
+    end
+
+    it "should fire events to matching listeners" do
+      listener = stub 'listener', :notify => nil, :name => "mylistener"
+      Instrumentation.subscribe(listener, :for_this_label, :all)
+      Instrumentation.listeners[0].enabled = true
+
+      listener.expects(:notify).with(:for_this_label, :start, {})
+
+      Instrumentation.publish(:for_this_label, :start, {})
+    end
+
+    it "should not fire events to non-matching listeners" do
+      listener1 = stub 'listener1', :notify => nil, :name => "mylistener1"
+      listener2 = stub 'listener2', :notify => nil, :name => "mylistener2"
+      Instrumentation.subscribe(listener1, :for_this_label, :all)
+      Instrumentation.listeners[0].enabled = true
+      Instrumentation.subscribe(listener2, :for_this_other_label, :all)
+      Instrumentation.listeners[1].enabled = true
+
+      listener1.expects(:notify).never
+      listener2.expects(:notify).with(:for_this_other_label, :start, {})
+
+      Instrumentation.publish(:for_this_other_label, :start, {})
+    end
+  end
+
+  describe "when instrumenting code" do
+    before(:each) do
+      Instrumentation.stubs(:publish)
+    end
+    describe "with a block" do
+      it "should execute it" do
+        executed = false
+        Instrumentation.instrument(:event) do
+          executed = true
+        end
+        executed.should be_true
+      end
+
+      it "should publish an event before execution" do
+        Instrumentation.expects(:publish).with { |label,event,data| label == :event && event == :start }
+        Instrumentation.instrument(:event) {}
+      end
+
+      it "should publish an event after execution" do
+        Instrumentation.expects(:publish).with { |label,event,data| label == :event && event == :stop }
+        Instrumentation.instrument(:event) {}
+      end
+
+      it "should publish the event even when block raised an exception" do
+        Instrumentation.expects(:publish).with { |label,event,data| label == :event }
+        lambda { Instrumentation.instrument(:event) { raise "not working" } }.should raise_error
+      end
+
+      it "should retain start end finish time of the event" do
+        Instrumentation.expects(:publish).with { |label,event,data| data.include?(:started) and data.include?(:finished) }
+        Instrumentation.instrument(:event) {}
+      end
+    end
+
+    describe "without a block" do
+      it "should raise an error if stop is called with no matching start" do
+        lambda{ Instrumentation.stop(:event) }.should raise_error
+      end
+
+      it "should publish an event on stop" do
+        Instrumentation.expects(:publish).with { |label,event,data| event == :start }
+        Instrumentation.expects(:publish).with { |label,event,data| event == :stop and data.include?(:started) and data.include?(:finished) }
+        data = {}
+        Instrumentation.start(:event, data)
+        Instrumentation.stop(:event, 1, data)
+      end
+
+      it "should return a different id per event" do
+        data = {}
+        Instrumentation.start(:event, data).should == 1
+        Instrumentation.start(:event, data).should == 2
+      end
+    end
+  end
+end

data/spec/unit/util/pidlock_spec.rb

@@ -0,0 +1,208 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/pidlock'
+
+describe Puppet::Util::Pidlock do
+  require 'puppet_spec/files'
+  include PuppetSpec::Files
+
+  before(:each) do
+    @lockfile = tmpfile("lock")
+    @lock = Puppet::Util::Pidlock.new(@lockfile)
+  end
+
+  it "should not be anonymous" do
+    @lock.should_not be_anonymous
+  end
+
+  describe "#lock" do
+    it "should not be locked at start" do
+      @lock.should_not be_locked
+    end
+
+    it "should not be mine at start" do
+      @lock.should_not be_mine
+    end
+
+    it "should become locked" do
+      @lock.lock
+      @lock.should be_locked
+    end
+
+    it "should become mine" do
+      @lock.lock
+      @lock.should be_mine
+    end
+
+    it "should be possible to lock multiple times" do
+      @lock.lock
+      lambda { @lock.lock }.should_not raise_error
+    end
+
+    it "should return true when locking" do
+      @lock.lock.should be_true
+    end
+
+    it "should return true if locked by me" do
+      @lock.lock
+      @lock.lock.should be_true
+    end
+
+    it "should return false if locked by someone else" do
+      Process.stubs(:kill)
+      File.open(@lockfile, "w") { |fd| fd.print('0') }
+
+      @lock.lock.should be_false
+    end
+
+    it "should create a lock file" do
+      @lock.lock
+      File.should be_exists(@lockfile)
+    end
+
+    it "should create a lock file containing our pid" do
+      @lock.lock
+      File.read(@lockfile).to_i.should == Process.pid.to_i
+    end
+  end
+
+  describe "#unlock" do
+    it "should not be locked anymore" do
+      @lock.lock
+      @lock.unlock
+      @lock.should_not be_locked
+    end
+
+    it "should return false if not locked" do
+      @lock.unlock.should be_false
+    end
+
+    it "should return true if properly unlocked" do
+      @lock.lock
+      @lock.unlock.should be_true
+    end
+
+    it "should get rid of the lock file" do
+      @lock.lock
+      @lock.unlock
+      File.should_not be_exists(@lockfile)
+    end
+
+    it "should not warn if the lockfile was deleted by someone else" do
+      @lock.lock
+      File.unlink(@lockfile)
+
+      Puppet.expects(:err).never # meh
+      @lock.unlock
+    end
+
+    it "should warn if the lockfile can't be deleted" do
+      @lock.lock
+      File.expects(:unlink).with(@lockfile).raises(Errno::EIO)
+      Puppet.expects(:err).with do |argument|
+        argument.should =~ /Input\/output error/
+      end
+      @lock.unlock
+
+      # This is necessary because our cleanup code uses File.unlink
+      File.unstub(:unlink)
+      @lock.unlock
+    end
+  end
+
+  describe "#locked?" do
+    it "should return true if locked" do
+      @lock.lock
+      @lock.should be_locked
+    end
+  end
+
+  describe "with a stale lock" do
+    before(:each) do
+      Process.stubs(:kill).with(0, 6789)
+      Process.stubs(:kill).with(0, 1234).raises(Errno::ESRCH)
+      Process.stubs(:pid).returns(6789)
+      File.open(@lockfile, 'w') { |fd| fd.write("1234") }
+    end
+
+    it "should not be locked" do
+      @lock.should_not be_locked
+    end
+
+    describe "#lock" do
+      it "should clear stale locks" do
+        @lock.locked?
+        File.should_not be_exists(@lockfile)
+      end
+
+      it "should replace with new locks" do
+        @lock.lock
+        File.should be_exists(@lockfile)
+        @lock.lock_pid.should == 6789
+        @lock.should be_mine
+        @lock.should be_locked
+      end
+    end
+
+    describe "#unlock" do
+      it "should not be allowed" do
+        @lock.unlock.should be_false
+      end
+
+      it "should not remove the lock file" do
+        @lock.unlock
+        File.should be_exists(@lockfile)
+      end
+    end
+  end
+
+  describe "with another process lock" do
+    before(:each) do
+      Process.stubs(:kill).with(0, 6789)
+      Process.stubs(:kill).with(0, 1234)
+      Process.stubs(:pid).returns(6789)
+      File.open(@lockfile, 'w') { |fd| fd.write("1234") }
+    end
+
+    it "should be locked" do
+      @lock.should be_locked
+    end
+
+    it "should not be mine" do
+      @lock.should_not be_mine
+    end
+
+    describe "#lock" do
+      it "should not be possible" do
+        @lock.lock.should be_false
+      end
+
+      it "should not overwrite the lock" do
+        @lock.lock
+        @lock.should_not be_mine
+      end
+    end
+
+    describe "#unlock" do
+      it "should not be possible" do
+        @lock.unlock.should be_false
+      end
+
+      it "should not remove the lock file" do
+        @lock.unlock
+        File.should be_exists(@lockfile)
+      end
+
+      it "should still not be our lock" do
+        @lock.unlock
+        @lock.should_not be_mine
+      end
+
+      it "should not warn" do
+        Puppet.expects(:err).never
+        @lock.unlock
+      end
+    end
+  end
+end