puppet 2.7.11 → 2.7.12

data/lib/puppet/agent/disabler.rb

@@ -1,27 +0,0 @@
-require 'puppet/util/anonymous_filelock'
-
-module Puppet::Agent::Disabler
-  # Let the daemon run again, freely in the filesystem.
-  def enable
-    disable_lockfile.unlock
-  end
-
-  # Stop the daemon from making any catalog runs.
-  def disable(msg='')
-    disable_lockfile.lock(msg)
-  end
-
-  def disable_lockfile
-    @disable_lockfile ||= Puppet::Util::AnonymousFilelock.new(lockfile_path+".disabled")
-
-    @disable_lockfile
-  end
-
-  def disabled?
-    disable_lockfile.locked?
-  end
-
-  def disable_message
-    disable_lockfile.message
-  end
-end

data/lib/puppet/util/anonymous_filelock.rb

@@ -1,36 +0,0 @@
-
-class Puppet::Util::AnonymousFilelock
-  attr_reader :lockfile
-
-  def initialize(lockfile)
-    @lockfile = lockfile
-  end
-
-  def anonymous?
-    true
-  end
-
-  def lock(msg = '')
-    return false if locked?
-
-    File.open(@lockfile, 'w') { |fd| fd.print(msg) }
-    true
-  end
-
-  def unlock
-    if locked?
-      File.unlink(@lockfile)
-      true
-    else
-      false
-    end
-  end
-
-  def locked?
-    File.exists? @lockfile
-  end
-
-  def message
-    return File.read(@lockfile) if locked?
-  end
-end

data/spec/unit/agent/disabler_spec.rb

@@ -1,60 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-require 'puppet/agent'
-require 'puppet/agent/locker'
-
-class LockerTester
-  include Puppet::Agent::Disabler
-end
-
-describe Puppet::Agent::Disabler do
-  before do
-    @locker = LockerTester.new
-    @locker.stubs(:lockfile_path).returns "/my/lock"
-  end
-
-  it "should use an AnonymousFilelock instance as its disable_lockfile" do
-    @locker.disable_lockfile.should be_instance_of(Puppet::Util::AnonymousFilelock)
-  end
-
-  it "should use 'lockfile_path' to determine its disable_lockfile path" do
-    @locker.expects(:lockfile_path).returns "/my/lock"
-    lock = Puppet::Util::AnonymousFilelock.new("/my/lock")
-    Puppet::Util::AnonymousFilelock.expects(:new).with("/my/lock.disabled").returns lock
-
-    @locker.disable_lockfile
-  end
-
-  it "should reuse the same lock file each time" do
-    @locker.disable_lockfile.should equal(@locker.disable_lockfile)
-  end
-
-  it "should lock the anonymous lock when disabled" do
-    @locker.disable_lockfile.expects(:lock)
-
-    @locker.disable
-  end
-
-  it "should disable with a message" do
-    @locker.disable_lockfile.expects(:lock).with("disabled because")
-
-    @locker.disable("disabled because")
-  end
-
-  it "should unlock the anonymous lock when enabled" do
-    @locker.disable_lockfile.expects(:unlock)
-
-    @locker.enable
-  end
-
-  it "should check the lock if it is disabled" do
-    @locker.disable_lockfile.expects(:locked?)
-
-    @locker.disabled?
-  end
-
-  it "should report the disable message when disabled" do
-    @locker.disable_lockfile.expects(:message).returns("message")
-    @locker.disable_message.should == "message"
-  end
-end

data/spec/unit/module_tool/repository_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'net/http'
-require 'puppet/module_tool'
-
-describe Puppet::Module::Tool::Repository do
-  describe 'instances' do
-    before do
-      @repository = described_class.new('http://fake.com')
-    end
-
-    describe '#make_http_request' do
-      before do
-        # Do a mock of the Proxy call so we can do proper expects for
-        # Net::HTTP
-        Net::HTTP.expects(:Proxy).returns(Net::HTTP)
-        Net::HTTP.expects(:start)
-      end
-      context "when not given an :authenticate option" do
-        it "should authenticate" do
-          @repository.expects(:authenticate).never
-          @repository.make_http_request(nil)
-        end
-      end
-      context "when given an :authenticate option" do
-        it "should authenticate" do
-          @repository.expects(:authenticate)
-          @repository.make_http_request(nil, :authenticate => true)
-        end
-      end
-    end
-
-    describe '#authenticate' do
-      it "should set basic auth on the request" do
-        authenticated_request = stub
-        authenticated_request.expects(:basic_auth)
-        @repository.expects(:prompt).twice
-        @repository.authenticate(authenticated_request)
-      end
-    end
-
-    describe '#retrieve' do
-      before do
-        @uri = URI.parse('http://some.url.com')
-      end
-
-      it "should access the cache" do
-        @repository.cache.expects(:retrieve).with(@uri)
-        @repository.retrieve(@uri)
-      end
-    end
-  end
-end

data/spec/unit/util/anonymous_filelock_spec.rb

@@ -1,78 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-require 'puppet/util/anonymous_filelock'
-
-describe Puppet::Util::AnonymousFilelock do
-  require 'puppet_spec/files'
-  include PuppetSpec::Files
-
-  before(:each) do
-    @lockfile = tmpfile("lock")
-    @lock = Puppet::Util::AnonymousFilelock.new(@lockfile)
-  end
-
-  it "should be anonymous" do
-    @lock.should be_anonymous
-  end
-
-  describe "#lock" do
-    it "should return false if already locked" do
-      @lock.stubs(:locked?).returns(true)
-      @lock.lock.should be_false
-    end
-
-    it "should return true if it successfully locked" do
-      @lock.lock.should be_true
-    end
-
-    it "should create a lock file" do
-      @lock.lock
-
-      File.should be_exists(@lockfile)
-    end
-
-    it "should create a lock file containing a message" do
-      @lock.lock("message")
-
-      File.read(@lockfile).should == "message"
-    end
-  end
-
-  describe "#unlock" do
-    it "should return true when unlocking" do
-      @lock.lock
-      @lock.unlock.should be_true
-    end
-
-    it "should return false when not locked" do
-      @lock.unlock.should be_false
-    end
-
-    it "should clear the lock file" do
-      File.open(@lockfile, 'w') { |fd| fd.print("locked") }
-      @lock.unlock
-      File.should_not be_exists(@lockfile)
-    end
-  end
-
-  it "should be locked when locked" do
-    @lock.lock
-    @lock.should be_locked
-  end
-
-  it "should not be locked when not locked" do
-    @lock.should_not be_locked
-  end
-
-  it "should not be locked when unlocked" do
-    @lock.lock
-    @lock.unlock
-    @lock.should_not be_locked
-  end
-
-  it "should return the lock message" do
-    @lock.lock("lock message")
-    @lock.message.should == "lock message"
-  end
-end

data/spec/unit/util/pidlock_spec.rb

@@ -1,208 +0,0 @@
-#!/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