puppet 3.0.0.rc5 → 3.0.0.rc7

data/conf/osx/preflight

@@ -1,24 +0,0 @@
-#!/bin/bash
-#
-# Make sure that old puppet cruft is removed
-# This also allows us to downgrade puppet as
-# it's more likely that installing old versions
-# over new will cause issues.
-#
-# ${3} is the destination volume so that this works correctly
-# when being installed to volumes other than the current OS.
-
-/bin/rm -Rf "${3}{SITELIBDIR}/puppet"
-/bin/rm -Rf "${3}{SITELIBDIR}/puppet.rb"
-
-# remove old doc files
-
-/bin/rm -Rf "${3}/usr/share/doc/puppet"
-
-# In puppet 0.24.x these executables lived in bindir, but in 0.25.x they
-# have been moved to sbindir. This cleans out old ones before installing.
-/bin/rm -Rf "${3}{BINDIR}/puppetca"
-/bin/rm -Rf "${3}{BINDIR}/puppetd"
-/bin/rm -Rf "${3}{BINDIR}/puppetmasterd"
-/bin/rm -Rf "${3}{BINDIR}/puppetqd"
-/bin/rm -Rf "${3}{BINDIR}/puppetrun"

data/lib/puppet/network/http/mongrel.rb

@@ -1,35 +0,0 @@
-require 'mongrel' if Puppet.features.mongrel?
-
-require 'puppet/network/http/mongrel/rest'
-
-class Puppet::Network::HTTP::Mongrel
-  def initialize(args = {})
-    @listening = false
-  end
-
-  def listen(args = {})
-    raise ArgumentError, ":address must be specified." unless args[:address]
-    raise ArgumentError, ":port must be specified." unless args[:port]
-    raise "Mongrel server is already listening" if listening?
-
-    @server = Mongrel::HttpServer.new(args[:address], args[:port])
-    @server.register('/', Puppet::Network::HTTP::MongrelREST.new(:server => @server))
-
-    @listening = true
-    @server.run
-  end
-
-  def unlisten
-    raise "Mongrel server is not listening" unless listening?
-    # We wait until the running process has terminated, rather than letting
-    # the shutdown happen in the background.  This might delay exit, but is
-    # nicer than the alternative of killing something horribly. --daniel 2012-03-12
-    @server.stop(true)
-    @server = nil
-    @listening = false
-  end
-
-  def listening?
-    @listening
-  end
-end

data/lib/puppet/util/config_timeout.rb

@@ -1,24 +0,0 @@
-module Puppet::Util::ConfigTimeout
-  # NOTE: in the future it might be a good idea to add an explicit "integer" type to
-  #  the settings types, in which case this would no longer be necessary.
-
-  # Get the value of puppet's "configtimeout" setting, as an integer.  Raise an
-  # ArgumentError if the setting does not contain a valid integer value.
-  # @return Puppet config timeout setting value, as an integer
-  def timeout_interval
-    timeout = Puppet[:configtimeout]
-    case timeout
-    when String
-      if timeout =~ /^\d+$/
-        timeout = Integer(timeout)
-      else
-        raise ArgumentError, "Configuration timeout must be an integer"
-      end
-    when Integer # nothing
-    else
-      raise ArgumentError, "Configuration timeout must be an integer"
-    end
-
-    timeout
-  end
-end

data/spec/unit/network/http/mongrel/rest_spec.rb

@@ -1,257 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-require 'puppet/network/http'
-
-describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel? do
-  before do
-    require 'puppet/network/http/mongrel/rest'
-  end
-
-
-  it "should include the Puppet::Network::HTTP::Handler module" do
-    Puppet::Network::HTTP::MongrelREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
-  end
-
-  describe "when initializing" do
-    it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
-      Puppet::Network::HTTP::MongrelREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
-      Puppet::Network::HTTP::MongrelREST.new(:server => "my", :handler => "arguments")
-    end
-  end
-
-  describe "when receiving a request" do
-    before do
-      @params = {}
-      @request = stub('mongrel http request', :params => @params)
-
-      @head = stub('response head')
-      @body = stub('response body', :write => true)
-      @response = stub('mongrel http response')
-      @response.stubs(:start).yields(@head, @body)
-      @model_class = stub('indirected model class')
-      @mongrel = stub('mongrel http server', :register => true)
-      Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
-      @handler = Puppet::Network::HTTP::MongrelREST.new(:server => @mongrel, :handler => :foo)
-    end
-
-    describe "and using the HTTP Handler interface" do
-      it "should return the HTTP_ACCEPT parameter as the accept header" do
-        @params.expects(:[]).with("HTTP_ACCEPT").returns "myaccept"
-        @handler.accept_header(@request).should == "myaccept"
-      end
-
-      it "should return the Content-Type parameter as the Content-Type header" do
-        @params.expects(:[]).with("HTTP_CONTENT_TYPE").returns "mycontent"
-        @handler.content_type_header(@request).should == "mycontent"
-      end
-
-      it "should use the REQUEST_METHOD as the http method" do
-        @params.expects(:[]).with(Mongrel::Const::REQUEST_METHOD).returns "mymethod"
-        @handler.http_method(@request).should == "mymethod"
-      end
-
-      it "should return the request path as the path" do
-        @params.expects(:[]).with(Mongrel::Const::REQUEST_PATH).returns "/foo/bar"
-        @handler.path(@request).should == "/foo/bar"
-      end
-
-      it "should return the request body as the body" do
-        @request.stubs(:body).returns StringIO.new("mybody")
-        @handler.body(@request).should == "mybody"
-      end
-
-      it "should set the response's content-type header when setting the content type" do
-        @header = mock 'header'
-        @response.expects(:header).returns @header
-        @header.expects(:[]=).with('Content-Type', "mytype")
-
-        @handler.set_content_type(@response, "mytype")
-      end
-
-      it "should set the status and write the body when setting the response for a successful request" do
-        head = mock 'head'
-        body = mock 'body'
-        @response.expects(:start).with(200).yields(head, body)
-
-        body.expects(:write).with("mybody")
-
-        @handler.set_response(@response, "mybody", 200)
-      end
-
-      describe "when the result is a File" do
-        it "should use response send_file" do
-          head = mock 'head'
-          body = mock 'body'
-          stat = stub 'stat', :size => 100
-          file = stub 'file', :stat => stat, :path => "/tmp/path"
-          file.stubs(:is_a?).with(File).returns(true)
-
-          @response.expects(:start).with(200).yields(head, body)
-          @response.expects(:send_status).with(100)
-          @response.expects(:send_header)
-          @response.expects(:send_file).with("/tmp/path")
-
-          @handler.set_response(@response, file, 200)
-        end
-      end
-
-      it "should set the status and reason and write the body when setting the response for a successful request" do
-        head = mock 'head'
-        body = mock 'body'
-        @response.expects(:start).with(400, false, "mybody").yields(head, body)
-
-        body.expects(:write).with("mybody")
-
-        @handler.set_response(@response, "mybody", 400)
-      end
-    end
-
-    describe "and determining the request parameters" do
-      before do
-        @params = {'REQUEST_METHOD' => 'GET'}
-        @request.stubs(:params).returns(@params)
-      end
-
-      it "should skip empty parameter values" do
-        @params['QUERY_STRING'] = "&="
-        lambda { @handler.params(@request) }.should_not raise_error
-      end
-
-      it "should include the HTTP request parameters, with the keys as symbols" do
-        @params['QUERY_STRING'] = 'foo=baz&bar=xyzzy'
-        result = @handler.params(@request)
-        result[:foo].should == "baz"
-        result[:bar].should == "xyzzy"
-      end
-
-      it "should CGI-decode the HTTP parameters" do
-        escaped = CGI.escape("foo bar")
-        @params['QUERY_STRING'] = "foo=#{escaped}"
-        result = @handler.params(@request)
-        result[:foo].should == "foo bar"
-      end
-
-      it "should include parameters from the body of a POST request" do
-        @params.merge!(
-          'QUERY_STRING'   => nil,
-          'REQUEST_METHOD' => 'POST'
-        )
-        body = StringIO.new('foo=bar&baz=qux')
-        @request.stubs(:body).returns(body)
-
-        @handler.params(@request).should include(
-          :foo => 'bar',
-          :baz => 'qux'
-        )
-      end
-
-      it "should convert the string 'true' to the boolean" do
-        @params['QUERY_STRING'] = 'foo=true'
-        result = @handler.params(@request)
-        result[:foo].should be_true
-      end
-
-      it "should convert the string 'false' to the boolean" do
-        @params['QUERY_STRING'] = 'foo=false'
-        result = @handler.params(@request)
-        result[:foo].should be_false
-      end
-
-      it "should convert integer arguments to Integers" do
-        @params['QUERY_STRING'] = 'foo=15'
-        result = @handler.params(@request)
-        result[:foo].should == 15
-      end
-
-      it "should convert floating point arguments to Floats" do
-        @params['QUERY_STRING'] = 'foo=1.5'
-        result = @handler.params(@request)
-        result[:foo].should == 1.5
-      end
-
-      it "should YAML-load and URI-decode values that are YAML-encoded" do
-        escaping = CGI.escape(YAML.dump(%w{one two}))
-        @params['QUERY_STRING'] = "foo=#{escaping}"
-        result = @handler.params(@request)
-        result[:foo].should == %w{one two}
-      end
-
-      it "should not allow the client to set the node via the query string" do
-        @params['QUERY_STRING'] = "node=foo"
-        @handler.params(@request)[:node].should be_nil
-      end
-
-      it "should not allow the client to set the IP address via the query string" do
-        @params['QUERY_STRING'] = "ip=foo"
-        @handler.params(@request)[:ip].should be_nil
-      end
-
-      it "should pass the client's ip address to model find" do
-        @params['REMOTE_ADDR'] = "ipaddress"
-        @handler.params(@request)[:ip].should == "ipaddress"
-      end
-
-      it "should pass the client's provided X-Forwared-For value as the ip" do
-        @params["HTTP_X_FORWARDED_FOR"] = "ipaddress"
-        @handler.params(@request)[:ip].should == "ipaddress"
-      end
-
-      it "should pass the client's provided X-Forwared-For first value as the ip" do
-        @params["HTTP_X_FORWARDED_FOR"] = "ipproxy1,ipproxy2,ipaddress"
-        @handler.params(@request)[:ip].should == "ipaddress"
-      end
-
-      it "should pass the client's provided X-Forwared-For value as the ip instead of the REMOTE_ADDR" do
-        @params.merge!(
-          "REMOTE_ADDR"          => "remote_addr",
-          "HTTP_X_FORWARDED_FOR" => "ipaddress"
-        )
-        @handler.params(@request)[:ip].should == "ipaddress"
-      end
-
-      it "should retrieve the hostname by matching the certificate parameter from the header in :ssl_client_header" do
-        Puppet[:ssl_client_header] = "myheader"
-        @params["myheader"] = "/CN=host.domain.com"
-        @handler.params(@request)[:node].should == "host.domain.com"
-      end
-
-      it "should use :ssl_client_header and :ssl_client_verify_header to determine the parameter for checking whether the host certificate is valid" do
-        Puppet[:ssl_client_header] = "certheader"
-        Puppet[:ssl_client_verify_header] = "myheader"
-        @params.merge!(
-          "myheader"   => "SUCCESS",
-          "certheader" => "/CN=host.domain.com"
-        )
-        @handler.params(@request)[:authenticated].should be_true
-      end
-
-      it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
-        Puppet[:ssl_client_header] = "certheader"
-        Puppet[:ssl_client_verify_header] = "myheader"
-        @params.merge!(
-          "myheader"   => "whatever",
-          "certheader" => "/CN=host.domain.com"
-        )
-        @handler.params(@request)[:authenticated].should be_false
-      end
-
-      it "should consider the host unauthenticated if no certificate information is present" do
-        Puppet[:ssl_client_header] = "certheader"
-        Puppet[:ssl_client_verify_header] = "myheader"
-        @params.merge!(
-          "myheader"   => nil,
-          "certheader" => "SUCCESS"
-        )
-        @handler.params(@request)[:authenticated].should be_false
-      end
-
-      it "should resolve the node name with an ip address look-up if no certificate is present" do
-        Puppet[:ssl_client_header] = "myheader"
-        @params["myheader"] = nil
-        @handler.expects(:resolve_node).returns("host.domain.com")
-        @handler.params(@request)[:node].should == "host.domain.com"
-      end
-    end
-  end
-end

data/spec/unit/network/http/mongrel_spec.rb

@@ -1,91 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'puppet/network/http'
-
-describe "Puppet::Network::HTTP::Mongrel", "after initializing", :if => Puppet.features.mongrel? do
-  it "should not be listening" do
-    require 'puppet/network/http/mongrel'
-
-    Puppet::Network::HTTP::Mongrel.new.should_not be_listening
-  end
-end
-
-describe "Puppet::Network::HTTP::Mongrel", "when turning on listening", :if => Puppet.features.mongrel? do
-  before do
-    require 'puppet/network/http/mongrel'
-
-    @server = Puppet::Network::HTTP::Mongrel.new
-    @mock_mongrel = mock('mongrel')
-    @mock_mongrel.stubs(:run)
-    @mock_mongrel.stubs(:register)
-    Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
-
-    @listen_params = { :address => "127.0.0.1", :port => 31337 }
-  end
-
-  it "should fail if already listening" do
-    @server.listen(@listen_params)
-    Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
-  end
-
-  it "should require a listening address to be specified" do
-    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
-  end
-
-  it "should require a listening port to be specified" do
-    Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
-  end
-
-  it "should order a mongrel server to start" do
-    @mock_mongrel.expects(:run)
-    @server.listen(@listen_params)
-  end
-
-  it "should tell mongrel to listen on the specified address and port" do
-    Mongrel::HttpServer.expects(:new).with("127.0.0.1", 31337).returns(@mock_mongrel)
-    @server.listen(@listen_params)
-  end
-
-  it "should be listening" do
-    Mongrel::HttpServer.expects(:new).returns(@mock_mongrel)
-    @server.listen(@listen_params)
-    @server.should be_listening
-  end
-
-  describe "when providing REST services" do
-    it "should instantiate a handler at / for handling REST calls" do
-      Puppet::Network::HTTP::MongrelREST.expects(:new).returns "myhandler"
-      @mock_mongrel.expects(:register).with("/", "myhandler")
-
-      @server.listen(@listen_params)
-    end
-  end
-end
-
-describe "Puppet::Network::HTTP::Mongrel", "when turning off listening", :if => Puppet.features.mongrel? do
-  before do
-    @mock_mongrel = mock('mongrel httpserver')
-    @mock_mongrel.stubs(:run)
-    @mock_mongrel.stubs(:register)
-    Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
-    @server = Puppet::Network::HTTP::Mongrel.new
-    @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ]}
-  end
-
-  it "should fail unless listening" do
-    Proc.new { @server.unlisten }.should raise_error(RuntimeError)
-  end
-
-  it "should order mongrel server to stop" do
-    @server.listen(@listen_params)
-    @mock_mongrel.expects(:stop)
-    @server.unlisten
-  end
-
-  it "should not be listening" do
-    @server.listen(@listen_params)
-    @mock_mongrel.stubs(:stop)
-    @server.unlisten
-    @server.should_not be_listening
-  end
-end

data/spec/unit/network/http_spec.rb

@@ -1,31 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-require 'puppet/network/http'
-
-describe Puppet::Network::HTTP do
-  it "should return the webrick HTTP server class when asked for a webrick server" do
-    Puppet::Network::HTTP.server_class_by_type(:webrick).should be(Puppet::Network::HTTP::WEBrick)
-  end
-
-  describe "when asked for a mongrel server" do
-    if Puppet.features.mongrel?
-      it "should return the mongrel server class" do
-        Puppet::Network::HTTP.server_class_by_type(:mongrel).should be(Puppet::Network::HTTP::Mongrel)
-      end
-    else
-      it "should fail" do
-        lambda { Puppet::Network::HTTP.server_class_by_type(:mongrel) }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  it "should fail to return the mongrel HTTP server class if mongrel is not available " do
-    Puppet.features.expects(:mongrel?).returns(false)
-    Proc.new { Puppet::Network::HTTP.server_class_by_type(:mongrel) }.should raise_error(ArgumentError)
-  end
-
-  it "should return an error when asked for an unknown server" do
-    Proc.new { Puppet::Network::HTTP.server_class_by_type :foo }.should raise_error(ArgumentError)
-  end
-end