puppet 0.25.5 → 2.6.0

data/lib/puppet/network/http/rack/xmlrpc.rb

@@ -3,63 +3,63 @@ require 'puppet/network/xmlrpc/server'
 require 'resolv'
 
 class Puppet::Network::HTTP::RackXMLRPC < Puppet::Network::HTTP::RackHttpHandler
-    def initialize(handlers)
-        @xmlrpc_server = Puppet::Network::XMLRPCServer.new
-        handlers.each do |name|
-            Puppet.debug "  -> register xmlrpc namespace %s" % name
-            unless handler = Puppet::Network::Handler.handler(name)
-                raise ArgumentError, "Invalid XMLRPC handler %s" % name
-            end
-            @xmlrpc_server.add_handler(handler.interface, handler.new({}))
-        end
-        super()
+  def initialize(handlers)
+    @xmlrpc_server = Puppet::Network::XMLRPCServer.new
+    handlers.each do |name|
+      Puppet.debug "  -> register xmlrpc namespace #{name}"
+      unless handler = Puppet::Network::Handler.handler(name)
+        raise ArgumentError, "Invalid XMLRPC handler #{name}"
+      end
+      @xmlrpc_server.add_handler(handler.interface, handler.new({}))
     end
+    super()
+  end
 
-    def process(request, response)
-        # errors are sent as text/plain
-        response['Content-Type'] = 'text/plain'
-        if not request.post? then
-            response.status = 405
-            response.write 'Method Not Allowed'
-            return
-        end
-        if request.media_type() != "text/xml" then
-            response.status = 400
-            response.write 'Bad Request'
-            return
-        end
+  def process(request, response)
+    # errors are sent as text/plain
+    response['Content-Type'] = 'text/plain'
+    if not request.post?
+      response.status = 405
+      response.write 'Method Not Allowed'
+      return
+    end
+    if request.media_type != "text/xml"
+      response.status = 400
+      response.write 'Bad Request'
+      return
+    end
 
-        # get auth/certificate data
-        client_request = build_client_request(request)
+    # get auth/certificate data
+    client_request = build_client_request(request)
 
-        response_body = @xmlrpc_server.process(request.body.read(), client_request)
+    response_body = @xmlrpc_server.process(request.body.read, client_request)
 
-        response.status = 200
-        response['Content-Type'] =  'text/xml; charset=utf-8'
-        response.write response_body
-    end
+    response.status = 200
+    response['Content-Type'] =  'text/xml; charset=utf-8'
+    response.write response_body
+  end
 
-    def build_client_request(request)
-        ip = request.ip
+  def build_client_request(request)
+    ip = request.ip
 
-        # if we find SSL info in the headers, use them to get a hostname.
-        # try this with :ssl_client_header, which defaults should work for
-        # Apache with StdEnvVars.
-        if dn = request.env[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
-            node = dn_matchdata[1].to_str
-            authenticated = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
-        else
-            begin
-                node = Resolv.getname(ip)
-            rescue => detail
-                Puppet.err "Could not resolve %s: %s" % [ip, detail]
-                node = "unknown"
-            end
-            authenticated = false
-        end
-
-        Puppet::Network::ClientRequest.new(node, ip, authenticated)
+    # if we find SSL info in the headers, use them to get a hostname.
+    # try this with :ssl_client_header, which defaults should work for
+    # Apache with StdEnvVars.
+    if dn = request.env[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
+      node = dn_matchdata[1].to_str
+      authenticated = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+    else
+      begin
+        node = Resolv.getname(ip)
+      rescue => detail
+        Puppet.err "Could not resolve #{ip}: #{detail}"
+        node = "unknown"
+      end
+      authenticated = false
     end
 
+    Puppet::Network::ClientRequest.new(node, ip, authenticated)
+  end
+
 end
 

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

@@ -8,136 +8,132 @@ require 'puppet/ssl/certificate'
 require 'puppet/ssl/certificate_revocation_list'
 
 class Puppet::Network::HTTP::WEBrick
-    def initialize(args = {})
-        @listening = false
-        @mutex = Mutex.new
+  def initialize(args = {})
+    @listening = false
+    @mutex = Mutex.new
+  end
+
+  def self.class_for_protocol(protocol)
+    return Puppet::Network::HTTP::WEBrickREST if protocol.to_sym == :rest
+    raise "Unknown protocol [#{protocol}]."
+  end
+
+  def listen(args = {})
+    raise ArgumentError, ":protocols must be specified." if !args[:protocols] or args[:protocols].empty?
+    raise ArgumentError, ":address must be specified." unless args[:address]
+    raise ArgumentError, ":port must be specified." unless args[:port]
+
+    @protocols = args[:protocols]
+    @xmlrpc_handlers = args[:xmlrpc_handlers]
+
+    arguments = {:BindAddress => args[:address], :Port => args[:port]}
+    arguments.merge!(setup_logger)
+    arguments.merge!(setup_ssl)
+
+    @server = WEBrick::HTTPServer.new(arguments)
+    @server.listeners.each { |l| l.start_immediately = false }
+
+    setup_handlers
+
+    @mutex.synchronize do
+      raise "WEBrick server is already listening" if @listening
+      @listening = true
+      @thread = Thread.new {
+        @server.start { |sock|
+          raise "Client disconnected before connection could be established" unless IO.select([sock],nil,nil,0.1)
+          sock.accept
+          @server.run(sock)
+        }
+      }
+      sleep 0.1 until @server.status == :Running
     end
-
-    def self.class_for_protocol(protocol)
-        return Puppet::Network::HTTP::WEBrickREST if protocol.to_sym == :rest
-        raise "Unknown protocol [#{protocol}]."
+  end
+
+  def unlisten
+    @mutex.synchronize do
+      raise "WEBrick server is not listening" unless @listening
+      @server.shutdown
+      @thread.join
+      @server = nil
+      @listening = false
     end
+  end
 
-    def listen(args = {})
-        raise ArgumentError, ":protocols must be specified." if !args[:protocols] or args[:protocols].empty?
-        raise ArgumentError, ":address must be specified." unless args[:address]
-        raise ArgumentError, ":port must be specified." unless args[:port]
-
-        @protocols = args[:protocols]
-        @xmlrpc_handlers = args[:xmlrpc_handlers]
-
-        arguments = {:BindAddress => args[:address], :Port => args[:port]}
-        arguments.merge!(setup_logger)
-        arguments.merge!(setup_ssl)
-
-        @server = WEBrick::HTTPServer.new(arguments)
-        @server.listeners.each { |l| l.start_immediately = false }
-
-        setup_handlers
-
-        @mutex.synchronize do
-            raise "WEBrick server is already listening" if @listening
-            @listening = true
-            @thread = Thread.new {
-                @server.start { |sock|
-                    raise "Client disconnected before connection could be established" unless IO.select([sock],nil,nil,0.1)
-                    sock.accept
-                    @server.run(sock)
-                }
-            }
-            sleep 0.1 until @server.status == :Running
-        end
+  def listening?
+    @mutex.synchronize do
+      @listening
     end
+  end
 
-    def unlisten
-        @mutex.synchronize do
-            raise "WEBrick server is not listening" unless @listening
-            @server.shutdown
-            @thread.join
-            @server = nil
-            @listening = false
-        end
-    end
+  # Configure our http log file.
+  def setup_logger
+    # Make sure the settings are all ready for us.
+    Puppet.settings.use(:main, :ssl, Puppet[:name])
 
-    def listening?
-        @mutex.synchronize do
-            @listening
-        end
+    if Puppet.run_mode.master?
+      file = Puppet[:masterhttplog]
+    else
+      file = Puppet[:httplog]
     end
 
-    # Configure our http log file.
-    def setup_logger
-        # Make sure the settings are all ready for us.
-        Puppet.settings.use(:main, :ssl, Puppet[:name])
-
-        if Puppet[:name] == "puppetmasterd"
-            file = Puppet[:masterhttplog]
-        else
-            file = Puppet[:httplog]
-        end
-
-        # open the log manually to prevent file descriptor leak
-        file_io = ::File.open(file, "a+")
-        file_io.sync
-        file_io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-
-        args = [file_io]
-        args << WEBrick::Log::DEBUG if Puppet::Util::Log.level == :debug
-
-        logger = WEBrick::Log.new(*args)
-        return :Logger => logger, :AccessLog => [
-            [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
-            [logger, WEBrick::AccessLog::REFERER_LOG_FORMAT ]
-        ]
-    end
+    # open the log manually to prevent file descriptor leak
+    file_io = ::File.open(file, "a+")
+    file_io.sync
+    file_io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
-    # Add all of the ssl cert information.
-    def setup_ssl
-        results = {}
+    args = [file_io]
+    args << WEBrick::Log::DEBUG if Puppet::Util::Log.level == :debug
 
-        # Get the cached copy.  We know it's been generated, too.
-        host = Puppet::SSL::Host.localhost
+    logger = WEBrick::Log.new(*args)
+    return :Logger => logger, :AccessLog => [
+      [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
+      [logger, WEBrick::AccessLog::REFERER_LOG_FORMAT ]
+    ]
+  end
 
-        raise Puppet::Error, "Could not retrieve certificate for %s and not running on a valid certificate authority" % host.name unless host.certificate
+  # Add all of the ssl cert information.
+  def setup_ssl
+    results = {}
 
-        results[:SSLPrivateKey] = host.key.content
-        results[:SSLCertificate] = host.certificate.content
-        results[:SSLStartImmediately] = true
-        results[:SSLEnable] = true
+    # Get the cached copy.  We know it's been generated, too.
+    host = Puppet::SSL::Host.localhost
 
-        unless Puppet::SSL::Certificate.find("ca")
-            raise Puppet::Error, "Could not find CA certificate"
-        end
+    raise Puppet::Error, "Could not retrieve certificate for #{host.name} and not running on a valid certificate authority" unless host.certificate
 
-        results[:SSLCACertificateFile] = Puppet[:localcacert]
-        results[:SSLVerifyClient] = OpenSSL::SSL::VERIFY_PEER
+    results[:SSLPrivateKey] = host.key.content
+    results[:SSLCertificate] = host.certificate.content
+    results[:SSLStartImmediately] = true
+    results[:SSLEnable] = true
 
-        results[:SSLCertificateStore] = host.ssl_store
+    raise Puppet::Error, "Could not find CA certificate" unless Puppet::SSL::Certificate.find(Puppet::SSL::CA_NAME)
 
-        results
-    end
+    results[:SSLCACertificateFile] = Puppet[:localcacert]
+    results[:SSLVerifyClient] = OpenSSL::SSL::VERIFY_PEER
 
-  private
+    results[:SSLCertificateStore] = host.ssl_store
 
-    def setup_handlers
-        # Set up the new-style protocols.
-        klass = self.class.class_for_protocol(:rest)
-        @server.mount('/', klass, :this_value_is_apparently_necessary_but_unused)
+    results
+  end
 
-        # And then set up xmlrpc, if configured.
-        if @protocols.include?(:xmlrpc) and ! @xmlrpc_handlers.empty?
-            @server.mount("/RPC2", xmlrpc_servlet)
-        end
-    end
+  private
 
-    # Create our xmlrpc servlet, which provides backward compatibility.
-    def xmlrpc_servlet
-        handlers = @xmlrpc_handlers.collect { |handler|
-            unless hclass = Puppet::Network::Handler.handler(handler)
-                raise "Invalid xmlrpc handler %s" % handler
-            end
-            hclass.new({})
-        }
-        Puppet::Network::XMLRPC::WEBrickServlet.new handlers
-    end
+  def setup_handlers
+    # Set up the new-style protocols.
+    klass = self.class.class_for_protocol(:rest)
+    @server.mount('/', klass, :this_value_is_apparently_necessary_but_unused)
+
+    # And then set up xmlrpc, if configured.
+    @server.mount("/RPC2", xmlrpc_servlet) if @protocols.include?(:xmlrpc) and ! @xmlrpc_handlers.empty?
+  end
+
+  # Create our xmlrpc servlet, which provides backward compatibility.
+  def xmlrpc_servlet
+    handlers = @xmlrpc_handlers.collect { |handler|
+      unless hclass = Puppet::Network::Handler.handler(handler)
+        raise "Invalid xmlrpc handler #{handler}"
+      end
+      hclass.new({})
+    }
+    Puppet::Network::XMLRPC::WEBrickServlet.new handlers
+  end
 end

data/lib/puppet/network/http/webrick/rest.rb

@@ -3,75 +3,78 @@ require 'resolv'
 
 class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
 
-    include Puppet::Network::HTTP::Handler
+  include Puppet::Network::HTTP::Handler
 
-    def initialize(server, handler)
-        raise ArgumentError, "server is required" unless server
-        super(server)
-        initialize_for_puppet(:server => server, :handler => handler)
-    end
+  def initialize(server, handler)
+    raise ArgumentError, "server is required" unless server
+    super(server)
+    initialize_for_puppet(:server => server, :handler => handler)
+  end
 
-    # Retrieve the request parameters, including authentication information.
-    def params(request)
-        result = request.query
-        result = decode_params(result)
-        result.merge(client_information(request))
-    end
+  # Retrieve the request parameters, including authentication information.
+  def params(request)
+    result = request.query
+    result = decode_params(result)
+    result.merge(client_information(request))
+  end
 
-    # WEBrick uses a service() method to respond to requests.  Simply delegate to the handler response() method.
-    def service(request, response)
-        process(request, response)
-    end
+  # WEBrick uses a service method to respond to requests.  Simply delegate to the handler response method.
+  def service(request, response)
+    process(request, response)
+  end
 
-    def accept_header(request)
-        request["accept"]
-    end
+  def accept_header(request)
+    request["accept"]
+  end
 
-    def content_type_header(request)
-        request["content-type"]
-    end
+  def content_type_header(request)
+    request["content-type"]
+  end
 
-    def http_method(request)
-        request.request_method
-    end
+  def http_method(request)
+    request.request_method
+  end
 
-    def path(request)
-        request.path
-    end
+  def path(request)
+    request.path
+  end
 
-    def body(request)
-        request.body
-    end
+  def body(request)
+    request.body
+  end
 
-    # Set the specified format as the content type of the response.
-    def set_content_type(response, format)
-        response["content-type"] = format_to_mime(format)
-    end
+  # Set the specified format as the content type of the response.
+  def set_content_type(response, format)
+    response["content-type"] = format_to_mime(format)
+  end
 
-    def set_response(response, result, status = 200)
-        response.status = status
-        response.body          = result if status >= 200 and status != 304
-        response.reason_phrase = result if status < 200 or status >= 300
+  def set_response(response, result, status = 200)
+    response.status = status
+    if status >= 200 and status != 304
+      response.body = result
+      response["content-length"] = result.stat.size if result.is_a?(File)
     end
+    response.reason_phrase = result if status < 200 or status >= 300
+  end
 
-    # Retrieve node/cert/ip information from the request object.
-    def client_information(request)
-        result = {}
-        if peer = request.peeraddr and ip = peer[3]
-            result[:ip] = ip
-        end
-
-        # If they have a certificate (which will almost always be true)
-        # then we get the hostname from the cert, instead of via IP
-        # info
-        result[:authenticated] = false
-        if cert = request.client_cert and nameary = cert.subject.to_a.find { |ary| ary[0] == "CN" }
-            result[:node] = nameary[1]
-            result[:authenticated] = true
-        else
-            result[:node] = resolve_node(result)
-        end
+  # Retrieve node/cert/ip information from the request object.
+  def client_information(request)
+    result = {}
+    if peer = request.peeraddr and ip = peer[3]
+      result[:ip] = ip
+    end
 
-        result
+    # If they have a certificate (which will almost always be true)
+    # then we get the hostname from the cert, instead of via IP
+    # info
+    result[:authenticated] = false
+    if cert = request.client_cert and nameary = cert.subject.to_a.find { |ary| ary[0] == "CN" }
+      result[:node] = nameary[1]
+      result[:authenticated] = true
+    else
+      result[:node] = resolve_node(result)
     end
+
+    result
+  end
 end