puppet 3.3.2 → 3.4.0.rc1

data/ext/rack/manifest.pp

@@ -1,59 +0,0 @@
-
-file { ["/etc/puppet/rack", "/etc/puppet/rack/public"]:
-  ensure => directory,
-  mode => 0755,
-  owner => root,
-  group => root,
-}
-file { "/etc/puppet/rack/config.ru":
-  ensure => present,
-  source => "puppet:///modules/rack/config.ru",
-  mode => 0644,
-  owner => puppet,
-  group => root,
-}
-file { "/etc/apache2/conf.d/puppetmasterd":
-  ensure => present,
-  source => "puppet:///modules/rack/apache2.conf",
-  mode => 0644,
-  owner => root,
-  group => root,
-  require => [File["/etc/puppet/rack/config.ru"], File["/etc/puppet/rack/public"], Package["apache2"], Package["passenger"]],
-  notify => Service["apache2"],
-}
-
-package { ["rack", "passenger"]:
-  ensure => installed,
-  provider => "gem",
-}
-
-service { "apache2":
-}
-
-case $lsbdistid {
-  "Debian": {
-    package { ["apache2-mpm-worker", "apache2-threaded-dev", "apache2"]:
-      ensure => installed,
-    }
-    file { "/etc/apache2/mods-enabled/ssl.load":
-      ensure => "../mods-available/ssl.load",
-      notify => Service["apache2"],
-      require => Package["apache2"],
-    }
-    Service["apache2"] {
-      require => Package["apache2"],
-    }
-    exec { "/var/lib/gems/1.8/bin/passenger-install-apache2-module --auto":
-      subscribe => Package["passenger"],
-      before => Service["apache2"],
-      require => Package[["passenger", "apache2-threaded-dev"]],
-    }
-  }
-}
-
-notice("You need to manually enable mod_passenger.so for Apache.")
-notice("Usually, you put these config stanzas into httpd.conf:")
-notice("   LoadModule passenger_module /var/lib/gems/1.8/gems/passenger-2.2.2/ext/apache2/mod_passenger.so")
-notice("   PassengerRoot /var/lib/gems/1.8/gems/passenger-2.2.2")
-notice("   PassengerRuby /usr/bin/ruby1.8")
-notice("--------------------------------------------------------")

data/lib/puppet/external/lock.rb

@@ -1,63 +0,0 @@
-require 'thread'
-require 'sync'
-
-# Gotten from:
-# http://path.berkeley.edu/~vjoel/ruby/solaris-bug.rb
-
-# Extensions to the File class for exception-safe file locking in a
-# environment with multiple user threads.
-
-# This is here because closing a file on solaris unlocks any locks that
-# other threads might have. So we have to make sure that only the last
-# reader thread closes the file.
-#
-# The hash maps inode number to a count of reader threads
-$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)
-  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/indirector/hiera.rb

@@ -1,39 +0,0 @@
-require 'puppet/indirector/terminus'
-
-class Puppet::Indirector::Hiera < Puppet::Indirector::Terminus
-  def initialize(*args)
-    if ! Puppet.features.hiera?
-      raise "Hiera terminus not supported without hiera library"
-    end
-    super
-  end
-
-  def find(request)
-    hiera.lookup(request.key, nil, request.options[:variables], nil, nil)
-  end
-
-  private
-
-  def self.hiera_config
-    hiera_config = Puppet.settings[:hiera_config]
-    config = {}
-
-    if File.exist?(hiera_config)
-      config = Hiera::Config.load(hiera_config)
-    else
-      Puppet.warning "Config file #{hiera_config} not found, using Hiera defaults"
-    end
-
-    config[:logger] = 'puppet'
-    config
-  end
-
-  def self.hiera
-    @hiera ||= Hiera.new(:config => hiera_config)
-  end
-
-  def hiera
-    self.class.hiera
-  end
-end
-

data/lib/puppet/parser/functions/foreach.rb

@@ -1,95 +0,0 @@
-Puppet::Parser::Functions::newfunction(
-:foreach,
-:type => :rvalue,
-:arity => 2,
-:doc => <<-'ENDHEREDOC') do |args|
-  Applies a parameterized block to each element in a sequence of selected entries from the first
-  argument and returns the first argument.
-
-  This function takes two mandatory arguments: the first should be an Array or a Hash, and the second
-  a parameterized block as produced by the puppet syntax:
-
-        $a.foreach {|$x| ... }
-
-  When the first argument is an Array, the parameterized block should define one or two block parameters.
-  For each application of the block, the next element from the array is selected, and it is passed to
-  the block if the block has one parameter. If the block has two parameters, the first is the elements
-  index, and the second the value. The index starts from 0.
-
-        $a.foreach {|$index, $value| ... }
-
-  When the first argument is a Hash, the parameterized block should define one or two parameters.
-  When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
-  and when two parameters are defined the iteration is performed with key and value.
-
-        $a.foreach {|$entry|       ..."key ${$entry[0]}, value ${$entry[1]}" }
-        $a.foreach {|$key, $value| ..."key ${key}, value ${value}" }
-
-  - Since 3.2
-  - requires `parser = future`.
-  ENDHEREDOC
-  require 'puppet/parser/ast/lambda'
-
-  def foreach_Array(o, scope, pblock)
-    return nil unless pblock
-
-    serving_size = pblock.parameter_count
-    if serving_size == 0
-      raise ArgumentError, "Block must define at least one parameter; value."
-    end
-    if serving_size > 2
-      raise ArgumentError, "Block must define at most two parameters; index, value"
-    end
-    enumerator = o.each
-    index = 0
-    if serving_size == 1
-      (o.size).times do
-        pblock.call(scope, enumerator.next)
-      end
-    else
-      (o.size).times do
-        pblock.call(scope, index, enumerator.next)
-        index = index +1
-      end
-    end
-    o
-  end
-
-  def foreach_Hash(o, scope, pblock)
-    return nil unless pblock
-    serving_size = pblock.parameter_count
-    case serving_size
-    when 0
-      raise ArgumentError, "Block must define at least one parameter (for hash entry key)."
-    when 1
-    when 2
-    else
-      raise ArgumentError, "Block must define at most two parameters (for hash entry key and value)."
-    end
-    enumerator = o.each_pair
-    if serving_size == 1
-      (o.size).times do
-        pblock.call(scope, enumerator.next)
-      end
-    else
-      (o.size).times do
-        pblock.call(scope, *enumerator.next)
-      end
-    end
-    o
-  end
-
-  raise ArgumentError, ("foreach(): wrong number of arguments (#{args.length}; must be 2)") if args.length != 2
-  receiver = args[0]
-  pblock = args[1]
-  raise ArgumentError, ("foreach(): wrong argument type (#{args[1].class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
-
-  case receiver
-  when Array
-    foreach_Array(receiver, self, pblock)
-  when Hash
-    foreach_Hash(receiver, self, pblock)
-  else
-    raise ArgumentError, ("foreach(): wrong argument type (#{args[0].class}; must be an Array or a Hash.")
-  end
-end

data/spec/integration/network/server/webrick_spec.rb

@@ -1,76 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/network/server'
-require 'puppet/ssl/certificate_authority'
-require 'socket'
-
-describe Puppet::Network::Server, :unless => Puppet.features.microsoft_windows? do
-  describe "when using webrick" do
-  include PuppetSpec::Files
-
-    # This reduces the odds of conflicting port numbers between concurrent runs
-    # of the suite on the same machine dramatically.
-    let(:port) { 20000 + ($$ % 40000) }
-    let(:address) { '127.0.0.1' }
-
-    before :each do
-      Puppet[:server] = '127.0.0.1'
-
-      # Get a safe temporary file
-      dir = tmpdir("webrick_integration_testing")
-
-      Puppet.settings[:confdir] = dir
-      Puppet.settings[:vardir] = dir
-      Puppet.settings[:logdir] = dir
-      Puppet.settings[:group] = Process.gid
-
-      Puppet::SSL::Host.ca_location = :local
-
-      ca = Puppet::SSL::CertificateAuthority.new
-      ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.indirection.find(Puppet[:certname])
-
-      @server = Puppet::Network::Server.new(address, port)
-    end
-
-    after do
-      Puppet::SSL::Host.ca_location = :none
-    end
-
-    describe "before listening" do
-      it "should not be reachable at the specified address and port" do
-        expect { TCPSocket.new('127.0.0.1', port) }.to raise_error
-      end
-    end
-
-    describe "when listening" do
-      it "should be reachable on the specified address and port" do
-        @server.start
-        expect { TCPSocket.new('127.0.0.1', port) }.to_not raise_error
-      end
-
-      it "should use any specified bind address" do
-        @server.stubs(:stop) # we're breaking listening internally, so we have to keep it from unlistening
-        Puppet::Network::HTTP::WEBrick.any_instance.expects(:listen).with(address, port)
-        @server.start
-      end
-
-      it "should not allow multiple servers to listen on the same address and port" do
-        @server.start
-        server2 = Puppet::Network::Server.new(address, port)
-        expect { server2.start }.to raise_error
-      end
-
-      after :each do
-        @server.stop if @server && @server.listening?
-      end
-    end
-
-    describe "after unlistening" do
-      it "should not be reachable on the port and address assigned" do
-        @server.start
-        @server.stop
-        expect { TCPSocket.new('127.0.0.1', port) }.to raise_error(Errno::ECONNREFUSED)
-      end
-    end
-  end
-end

data/spec/integration/parser/functions_spec.rb

@@ -1,16 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::Functions do
-  it "should support multiple threads autoloading the same function" do
-    threads = []
-    lambda {
-      10.times { |a|
-        threads << Thread.new {
-          Puppet::Parser::Functions.function("template")
-        }
-      }
-    }.should_not raise_error
-    threads.each { |t| t.join }
-  end
-end

data/spec/unit/indirector/hiera_spec.rb

@@ -1,154 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/hiera'
-require 'hiera/backend'
-
-describe Puppet::Indirector::Hiera do
-  include PuppetSpec::Files
-
-  def write_hiera_config(config_file, datadir)
-    File.open(config_file, 'w') do |f|
-      f.write("---
-        :yaml:
-          :datadir: #{datadir}
-        :hierarchy: ['global']
-        :logger: 'noop'
-        :backends: ['yaml']
-      ")
-    end
-  end
-
-  before do
-    Puppet.settings[:hiera_config] = hiera_config_file
-    write_hiera_config(hiera_config_file, datadir)
-
-    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    Puppet::Indirector::Indirection.stubs(:instance).returns(indirection)
-
-    module Testing; end
-    @hiera_class = class Testing::Hiera < Puppet::Indirector::Hiera
-      self
-    end
-  end
-
-  let(:model)   { mock('model') }
-  let(:options) { {:host => 'foo' } }
-
-  let(:request_integer) do
-    stub('request', :key => "integer", :options => options)
-  end
-
-  let(:request_string) do
-    stub('request', :key => "string", :options => options)
-  end
-
-  let(:request_array) do
-    stub('request', :key => "array", :options => options)
-  end
-
-  let(:request_hash) do
-    stub('request', :key => "hash", :options => options)
-  end
-
-  let(:indirection) do
-    stub('indirection', :name => :none, :register_terminus_type => nil,
-      :model => model)
-  end
-
-  let(:facts) do
-    { 'fqdn' => 'agent.testing.com' }
-  end
-  let(:facter_obj) { stub(:values => facts) }
-
-  let(:hiera_config_file) do
-    tmpfile("hiera.yaml")
-  end
-
-  let(:datadir) { my_fixture_dir }
-
-  it "should be the default data_binding terminus" do
-    Puppet.settings[:data_binding_terminus].should == :hiera
-  end
-
-  it "should raise an error if we don't have the hiera feature" do
-    Puppet.features.expects(:hiera?).returns(false)
-    lambda { @hiera_class.new }.should raise_error RuntimeError,
-      "Hiera terminus not supported without hiera library"
-  end
-
-  describe "the behavior of the hiera_config method", :if => Puppet.features.hiera? do
-    let(:default_hiera_config) do
-      {
-        :logger    => "puppet",
-        :backends  => ["yaml"],
-        :yaml      => { :datadir => datadir },
-        :hierarchy => ["global"]
-      }
-    end
-
-    it "should load the hiera config file by delegating to Hiera" do
-      Hiera::Config.expects(:load).with(hiera_config_file).returns({})
-      @hiera_class.hiera_config
-    end
-
-    it "should override the logger and set it to puppet" do
-      @hiera_class.hiera_config[:logger].should == "puppet"
-    end
-
-    it "should return a hiera configuration hash" do
-      results = @hiera_class.hiera_config
-      default_hiera_config.each do |key,value|
-        results[key].should == value
-      end
-      results.should be_a_kind_of Hash
-    end
-
-    context "when the Hiera configuration file does not exist" do
-      let(:path) { File.expand_path('/doesnotexist') }
-
-      before do
-        Puppet.settings[:hiera_config] = path
-      end
-
-      it "should log a warning" do
-        Puppet.expects(:warning).with(
-         "Config file #{path} not found, using Hiera defaults")
-        @hiera_class.hiera_config
-      end
-
-      it "should only configure the logger and set it to puppet" do
-        Puppet.expects(:warning).with(
-         "Config file #{path} not found, using Hiera defaults")
-        @hiera_class.hiera_config.should == { :logger => 'puppet' }
-      end
-    end
-  end
-
-  describe "the behavior of the find method", :if => Puppet.features.hiera? do
-
-    let(:data_binder) { @hiera_class.new }
-
-    it "should support looking up an integer" do
-      data_binder.find(request_integer).should == 3000
-    end
-
-    it "should support looking up a string" do
-      data_binder.find(request_string).should == 'apache'
-    end
-
-    it "should support looking up an array" do
-      data_binder.find(request_array).should == [
-        '0.ntp.puppetlabs.com',
-        '1.ntp.puppetlabs.com',
-      ]
-    end
-
-    it "should support looking up a hash" do
-      data_binder.find(request_hash).should == {
-        'user'  => 'Hightower',
-        'group' => 'admin',
-        'mode'  => '0644'
-      }
-    end
-  end
-end
-