puppet 0.25.5 → 2.6.0

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

@@ -3,55 +3,53 @@ 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, ":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]
-        raise "Mongrel server is already listening" if listening?
-
-        @protocols = args[:protocols]
-        @xmlrpc_handlers = args[:xmlrpc_handlers]
-        @server = Mongrel::HttpServer.new(args[:address], args[:port])
-        setup_handlers
-
-        @listening = true
-        @server.run
-    end
-
-    def unlisten
-        raise "Mongrel server is not listening" unless listening?
-        @server.stop
-        @server = nil
-        @listening = false
-    end
-
-    def listening?
-        @listening
-    end
+  def initialize(args = {})
+    @listening = false
+  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]
+    raise "Mongrel server is already listening" if listening?
+
+    @protocols = args[:protocols]
+    @xmlrpc_handlers = args[:xmlrpc_handlers]
+    @server = Mongrel::HttpServer.new(args[:address], args[:port])
+    setup_handlers
+
+    @listening = true
+    @server.run
+  end
+
+  def unlisten
+    raise "Mongrel server is not listening" unless listening?
+    @server.stop
+    @server = nil
+    @listening = false
+  end
+
+  def listening?
+    @listening
+  end
 
   private
 
-    def setup_handlers
-        # Register our REST support at /
-        klass = class_for_protocol(:rest)
-        @server.register('/', klass.new(:server => @server))
-
-        if @protocols.include?(:xmlrpc) and ! @xmlrpc_handlers.empty?
-            setup_xmlrpc_handlers
-        end
-    end
-
-    # Use our existing code to provide the xmlrpc backward compatibility.
-    def setup_xmlrpc_handlers
-        @server.register('/RPC2', Puppet::Network::HTTPServer::Mongrel.new(@xmlrpc_handlers))
-    end
-
-    def class_for_protocol(protocol)
-        return Puppet::Network::HTTP::MongrelREST if protocol.to_sym == :rest
-        raise ArgumentError, "Unknown protocol [#{protocol}]."
-    end
+  def setup_handlers
+    # Register our REST support at /
+    klass = class_for_protocol(:rest)
+    @server.register('/', klass.new(:server => @server))
+
+    setup_xmlrpc_handlers if @protocols.include?(:xmlrpc) and ! @xmlrpc_handlers.empty?
+  end
+
+  # Use our existing code to provide the xmlrpc backward compatibility.
+  def setup_xmlrpc_handlers
+    @server.register('/RPC2', Puppet::Network::HTTPServer::Mongrel.new(@xmlrpc_handlers))
+  end
+
+  def class_for_protocol(protocol)
+    return Puppet::Network::HTTP::MongrelREST if protocol.to_sym == :rest
+    raise ArgumentError, "Unknown protocol [#{protocol}]."
+  end
 end

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

@@ -2,84 +2,91 @@ require 'puppet/network/http/handler'
 
 class Puppet::Network::HTTP::MongrelREST < Mongrel::HttpHandler
 
-    include Puppet::Network::HTTP::Handler
+  include Puppet::Network::HTTP::Handler
 
-    ACCEPT_HEADER = "HTTP_ACCEPT".freeze # yay, zed's a crazy-man
+  ACCEPT_HEADER = "HTTP_ACCEPT".freeze # yay, zed's a crazy-man
 
-    def initialize(args={})
-        super()
-        initialize_for_puppet(args)
-    end
+  def initialize(args={})
+    super()
+    initialize_for_puppet(args)
+  end
 
-    def accept_header(request)
-        request.params[ACCEPT_HEADER]
-    end
+  def accept_header(request)
+    request.params[ACCEPT_HEADER]
+  end
 
-    def content_type_header(request)
-        request.params["HTTP_CONTENT_TYPE"]
-    end
+  def content_type_header(request)
+    request.params["HTTP_CONTENT_TYPE"]
+  end
 
-    # which HTTP verb was used in this request
-    def http_method(request)
-        request.params[Mongrel::Const::REQUEST_METHOD]
-    end
+  # which HTTP verb was used in this request
+  def http_method(request)
+    request.params[Mongrel::Const::REQUEST_METHOD]
+  end
 
-    # Return the query params for this request.  We had to expose this method for
-    # testing purposes.
-    def params(request)
-        params = Mongrel::HttpRequest.query_parse(request.params["QUERY_STRING"])
-        params = decode_params(params)
-        params.merge(client_info(request))
-    end
+  # Return the query params for this request.  We had to expose this method for
+  # testing purposes.
+  def params(request)
+    params = Mongrel::HttpRequest.query_parse(request.params["QUERY_STRING"])
+    params = decode_params(params)
+    params.merge(client_info(request))
+  end
 
-    # what path was requested?
-    def path(request)
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-        #x = '/' + request.params[Mongrel::Const::REQUEST_PATH]
-        request.params[Mongrel::Const::REQUEST_PATH]
-    end
+  # what path was requested?
+  def path(request)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    #x = '/' + request.params[Mongrel::Const::REQUEST_PATH]
+    request.params[Mongrel::Const::REQUEST_PATH]
+  end
 
-    # return the request body
-    def body(request)
-        request.body.read
-    end
+  # return the request body
+  def body(request)
+    request.body.read
+  end
 
-    def set_content_type(response, format)
-        response.header['Content-Type'] = format_to_mime(format)
-    end
+  def set_content_type(response, format)
+    response.header['Content-Type'] = format_to_mime(format)
+  end
 
-    # produce the body of the response
-    def set_response(response, result, status = 200)
-        # Set the 'reason' (or 'message', as it's called in Webrick), when
-        # we have a failure, unless we're on a version of mongrel that doesn't
-        # support this.
-        if status < 300
-            response.start(status) { |head, body| body.write(result) }
-        else
-            begin
-                response.start(status,false,result) { |head, body| body.write(result) }
-            rescue ArgumentError
-	        response.start(status)              { |head, body| body.write(result) }
-            end
-        end
+  # produce the body of the response
+  def set_response(response, result, status = 200)
+    # Set the 'reason' (or 'message', as it's called in Webrick), when
+    # we have a failure, unless we're on a version of mongrel that doesn't
+    # support this.
+    if status < 300
+      unless result.is_a?(File)
+        response.start(status) { |head, body| body.write(result) }
+      else
+        response.start(status) { |head, body| }
+        response.send_status(result.stat.size)
+        response.send_header
+        response.send_file(result.path)
+      end
+    else
+      begin
+        response.start(status,false,result) { |head, body| body.write(result) }
+      rescue ArgumentError
+        response.start(status)              { |head, body| body.write(result) }
+      end
     end
+  end
 
-    def client_info(request)
-        result = {}
-        params = request.params
-        result[:ip] = params["HTTP_X_FORWARDED_FOR"] ? params["HTTP_X_FORWARDED_FOR"].split(',').last.strip : params["REMOTE_ADDR"]
+  def client_info(request)
+    result = {}
+    params = request.params
+    result[:ip] = params["HTTP_X_FORWARDED_FOR"] ? params["HTTP_X_FORWARDED_FOR"].split(',').last.strip : params["REMOTE_ADDR"]
 
-        # JJM #906 The following dn.match regular expression is forgiving
-        # enough to match the two Distinguished Name string contents
-        # coming from Apache, Pound or other reverse SSL proxies.
-        if dn = params[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
-            result[:node] = dn_matchdata[1].to_str
-            result[:authenticated] = (params[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
-        else
-            result[:node] = resolve_node(result)
-            result[:authenticated] = false
-        end
-
-        return result
+    # JJM #906 The following dn.match regular expression is forgiving
+    # enough to match the two Distinguished Name string contents
+    # coming from Apache, Pound or other reverse SSL proxies.
+    if dn = params[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
+      result[:node] = dn_matchdata[1].to_str
+      result[:authenticated] = (params[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+    else
+      result[:node] = resolve_node(result)
+      result[:authenticated] = false
     end
+
+    result
+  end
 end

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

@@ -6,57 +6,57 @@ require 'puppet/network/http/rack/xmlrpc'
 # An rack application, for running the Puppet HTTP Server.
 class Puppet::Network::HTTP::Rack
 
-    def initialize(args)
-        raise ArgumentError, ":protocols must be specified." if !args[:protocols] or args[:protocols].empty?
-        protocols = args[:protocols]
+  def initialize(args)
+    raise ArgumentError, ":protocols must be specified." if !args[:protocols] or args[:protocols].empty?
+    protocols = args[:protocols]
 
-        # Always prepare a REST handler
-        @rest_http_handler = Puppet::Network::HTTP::RackREST.new()
-        protocols.delete :rest
+    # Always prepare a REST handler
+    @rest_http_handler = Puppet::Network::HTTP::RackREST.new
+    protocols.delete :rest
 
-        # Prepare the XMLRPC handler, for backward compatibility (if requested)
-        @xmlrpc_path = '/RPC2'
-        if args[:protocols].include?(:xmlrpc)
-            raise ArgumentError, "XMLRPC was requested, but no handlers were given" if !args.include?(:xmlrpc_handlers)
+    # Prepare the XMLRPC handler, for backward compatibility (if requested)
+    @xmlrpc_path = '/RPC2'
+    if args[:protocols].include?(:xmlrpc)
+      raise ArgumentError, "XMLRPC was requested, but no handlers were given" if !args.include?(:xmlrpc_handlers)
 
-            @xmlrpc_http_handler = Puppet::Network::HTTP::RackXMLRPC.new(args[:xmlrpc_handlers])
-            protocols.delete :xmlrpc
-        end
+      @xmlrpc_http_handler = Puppet::Network::HTTP::RackXMLRPC.new(args[:xmlrpc_handlers])
+      protocols.delete :xmlrpc
+    end
 
-        raise ArgumentError, "there were unknown :protocols specified." if !protocols.empty?
+    raise ArgumentError, "there were unknown :protocols specified." if !protocols.empty?
+  end
+
+  # The real rack application (which needs to respond to call).
+  # The work we need to do, roughly is:
+  # * Read request (from env) and prepare a response
+  # * Route the request to the correct handler
+  # * Return the response (in rack-format) to our caller.
+  def call(env)
+    request = Rack::Request.new(env)
+    response = Rack::Response.new
+    Puppet.debug 'Handling request: %s %s' % [request.request_method, request.fullpath]
+
+    # if we shall serve XMLRPC, have /RPC2 go to the xmlrpc handler
+    if @xmlrpc_http_handler and @xmlrpc_path == request.path_info[0, @xmlrpc_path.size]
+      handler = @xmlrpc_http_handler
+    else
+      # everything else is handled by the new REST handler
+      handler = @rest_http_handler
     end
 
-    # The real rack application (which needs to respond to call).
-    # The work we need to do, roughly is:
-    # * Read request (from env) and prepare a response
-    # * Route the request to the correct handler
-    # * Return the response (in rack-format) to our caller.
-    def call(env)
-        request = Rack::Request.new(env)
-        response = Rack::Response.new()
-        Puppet.debug 'Handling request: %s %s' % [request.request_method, request.fullpath]
-
-        # if we shall serve XMLRPC, have /RPC2 go to the xmlrpc handler
-        if @xmlrpc_http_handler and @xmlrpc_path == request.path_info[0, @xmlrpc_path.size]
-            handler = @xmlrpc_http_handler
-        else
-            # everything else is handled by the new REST handler
-            handler = @rest_http_handler
-        end
-
-        begin
-            handler.process(request, response)
-        rescue => detail
-            # Send a Status 500 Error on unhandled exceptions.
-            response.status = 500
-            response['Content-Type'] = 'text/plain'
-            response.write 'Internal Server Error: "%s"' % detail.message
-            # log what happened
-            Puppet.err "Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"" % detail.message
-            Puppet.err "Backtrace:"
-            detail.backtrace.each { |line| Puppet.err " > %s" % line }
-        end
-        response.finish()
+    begin
+      handler.process(request, response)
+    rescue => detail
+      # Send a Status 500 Error on unhandled exceptions.
+      response.status = 500
+      response['Content-Type'] = 'text/plain'
+      response.write 'Internal Server Error: "%s"' % detail.message
+      # log what happened
+      Puppet.err "Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"" % detail.message
+      Puppet.err "Backtrace:"
+      detail.backtrace.each { |line| Puppet.err " > #{line}" }
     end
+    response.finish
+  end
 end
 

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

@@ -3,14 +3,14 @@ require 'puppet/ssl/certificate'
 
 class Puppet::Network::HTTP::RackHttpHandler
 
-    def initialize()
-    end
+  def initialize
+  end
 
-    # do something useful with request (a Rack::Request) and use
-    # response to fill your Rack::Response
-    def process(request, response)
-        raise NotImplementedError, "Your RackHttpHandler subclass is supposed to override service(request)"
-    end
+  # do something useful with request (a Rack::Request) and use
+  # response to fill your Rack::Response
+  def process(request, response)
+    raise NotImplementedError, "Your RackHttpHandler subclass is supposed to override service(request)"
+  end
 
 end
 

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

@@ -3,77 +3,100 @@ require 'puppet/network/http/rack/httphandler'
 
 class Puppet::Network::HTTP::RackREST < Puppet::Network::HTTP::RackHttpHandler
 
-    include Puppet::Network::HTTP::Handler
+  include Puppet::Network::HTTP::Handler
 
-    HEADER_ACCEPT = 'HTTP_ACCEPT'.freeze
-    ContentType = 'Content-Type'.freeze
+  HEADER_ACCEPT = 'HTTP_ACCEPT'.freeze
+  ContentType = 'Content-Type'.freeze
 
-    def initialize(args={})
-        super()
-        initialize_for_puppet(args)
-    end
-
-    def set_content_type(response, format)
-        response[ContentType] = format_to_mime(format)
-    end
-
-    # produce the body of the response
-    def set_response(response, result, status = 200)
-        response.status = status
-        response.write result
-    end
+  CHUNK_SIZE = 8192
 
-    # Retrieve the accept header from the http request.
-    def accept_header(request)
-        request.env[HEADER_ACCEPT]
+  class RackFile
+    def initialize(file)
+      @file = file
     end
 
-    # Retrieve the accept header from the http request.
-    def content_type_header(request)
-        request.content_type
+    def each
+      while chunk = @file.read(CHUNK_SIZE)
+        yield chunk
+      end
     end
 
-    # Return which HTTP verb was used in this request.
-    def http_method(request)
-        request.request_method
+    def close
+      @file.close
     end
-
-    # Return the query params for this request.
-    def params(request)
-        result = decode_params(request.params)
-        result.merge(extract_client_info(request))
+  end
+
+  def initialize(args={})
+    super()
+    initialize_for_puppet(args)
+  end
+
+  def set_content_type(response, format)
+    response[ContentType] = format_to_mime(format)
+  end
+
+  # produce the body of the response
+  def set_response(response, result, status = 200)
+    response.status = status
+    unless result.is_a?(File)
+      response.write result
+    else
+      response["Content-Length"] = result.stat.size
+      response.body = RackFile.new(result)
     end
-
-    # what path was requested? (this is, without any query parameters)
-    def path(request)
-        request.path
+  end
+
+  # Retrieve the accept header from the http request.
+  def accept_header(request)
+    request.env[HEADER_ACCEPT]
+  end
+
+  # Retrieve the accept header from the http request.
+  def content_type_header(request)
+    request.content_type
+  end
+
+  # Return which HTTP verb was used in this request.
+  def http_method(request)
+    request.request_method
+  end
+
+  # Return the query params for this request.
+  def params(request)
+    result = decode_params(request.params)
+    result.merge(extract_client_info(request))
+  end
+
+  # what path was requested? (this is, without any query parameters)
+  def path(request)
+    request.path
+  end
+
+  # return the request body
+  # request.body has some limitiations, so we need to concat it back
+  # into a regular string, which is something puppet can use.
+  def body(request)
+    body = ''
+    request.body.each { |part| body += part }
+    body
+  end
+
+  def extract_client_info(request)
+    result = {}
+    result[: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*(.*)/)
+      result[:node] = dn_matchdata[1].to_str
+      result[:authenticated] = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+    else
+      result[:node] = resolve_node(result)
+      result[:authenticated] = false
     end
 
-    # return the request body
-    # request.body has some limitiations, so we need to concat it back
-    # into a regular string, which is something puppet can use.
-    def body(request)
-        body = ''
-        request.body.each { |part| body += part }
-        body
-    end
-
-    def extract_client_info(request)
-        result = {}
-        result[: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*(.*)/)
-            result[:node] = dn_matchdata[1].to_str
-            result[:authenticated] = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
-        else
-            result[:node] = resolve_node(result)
-            result[:authenticated] = false
-        end
-
-        result
-    end
+    result
+  end
 
 end