Class: Mongrel::HttpResponse

### Home Classes Methods

### In Files

- lib/mongrel/http_response.rb

### Parent

Object

### Methods

- ::new
- #done
- #done=
- #finished
- #reset
- #send_body
- #send_file
- #send_header
- #send_status
- #socket_error
- #start
- #write

### Files

- CHANGELOG
- COPYING
- LICENSE
- README
- Makefile

### Class/Module Index

Quicksearch

- Mongrel
- Mongrel::CGIWrapper
- Mongrel::Camping
- Mongrel::Camping::CampingHandler
- Mongrel::Command
- Mongrel::Command::Base
- Mongrel::Command::Registry
- Mongrel::Configurator
- Mongrel::Const
- Mongrel::DeflateFilter
- Mongrel::DirHandler
- Mongrel::Error404Handler
- Mongrel::Gems
- Mongrel::HeaderOut
- Mongrel::HttpHandler
- Mongrel::HttpHandlerPlugin
- Mongrel::HttpParams
- Mongrel::HttpParser
- Mongrel::HttpParserError
- Mongrel::HttpRequest
- Mongrel::HttpResponse
- Mongrel::HttpServer
- Mongrel::Rails
- Mongrel::Rails::RailsConfigurator
- Mongrel::Rails::RailsHandler
- Mongrel::RedirectHandler
- Mongrel::StatisticsFilter
- Mongrel::Stats
- Mongrel::StatusHandler
- Mongrel::StopServer
- Mongrel::TimeoutError
- Mongrel::URIClassifier
- Mongrel::URIClassifier::RegistrationError
- Mongrel::URIClassifier::UsageError
- RequestLog
- RequestLog::Access
- RequestLog::Files
- RequestLog::Objects
- RequestLog::Params
- RequestLog::Threads
- IO
- Kernel
- MongrelDbg
- TCPServer

No matching classes.

# Mongrel::HttpResponse

Writes and controls your response to the client using the HTTP/1.1 specification. You use it by simply doing:

    response.start(200) do |head,out|
      head['Content-Type'] = 'text/plain'
      out.write("hello\n")
    end

The parameter to start is the response code--which Mongrel will translate for you based on HTTP_STATUS_CODES. The head parameter is how you write custom headers. The out parameter is where you write your body. The default status code for HttpResponse.start is 200 so the above example is redundant.

As you can see, it's just like using a Hash and as you do this it writes the proper header to the output on the fly. You can even intermix specifying headers and writing content. The HttpResponse class with write the things in the proper order once the HttpResponse.block is ended.

You may also work the HttpResponse object directly using the various attributes available for the raw socket, body, header, and status codes. If you do this you're on your own. A design decision was made to force the client to not pipeline requests. HTTP/1.1 pipelining really kills the performance due to how it has to be handled and how unclear the standard is. To fix this the HttpResponse gives a "Connection: close" header which forces the client to close right away. The bonus for this is that it gives a pretty nice speed boost to most clients since they can close their connection immediately.

One additional caveat is that you don't have to specify the Content-length header as the HttpResponse will write this for you based on the out length.

### Attributes

body[RW]
body_sent[R]
header[R]
header_sent[R]
socket[R]
status[RW]
status_sent[R]

### Public Class Methods

new(socket) click to toggle source

    # File lib/mongrel/http_response.rb, line 42
    def initialize(socket)
      @socket = socket
      @body = StringIO.new
      @status = 404
      @reason = nil
      @header = HeaderOut.new(StringIO.new)
      @header[Const::DATE] = Time.now.httpdate
      @body_sent = false
      @header_sent = false
      @status_sent = false
    end

### Public Instance Methods

done() click to toggle source

    # File lib/mongrel/http_response.rb, line 158
    def done
      (@status_sent and @header_sent and @body_sent)
    end

done=(val) click to toggle source

Used during error conditions to mark the response as "done" so there isn't any more processing sent to the client.

    # File lib/mongrel/http_response.rb, line 152
    def done=(val)
      @status_sent = true
      @header_sent = true
      @body_sent = true
    end

finished() click to toggle source

This takes whatever has been done to header and body and then writes it in the proper format to make an HTTP/1.1 response.

    # File lib/mongrel/http_response.rb, line 144
    def finished
      send_status
      send_header
      send_body
    end

reset() click to toggle source

Primarily used in exception handling to reset the response output in order to write an alternative response. It will abort with an exception if you have already sent the header or the body. This is pretty catastrophic actually.

    # File lib/mongrel/http_response.rb, line 72
    def reset
      if @body_sent
        raise "You have already sent the request body."
      elsif @header_sent
        raise "You have already sent the request headers."
      else
        @header.out.truncate(0)
        @body.close
        @body = StringIO.new
      end
    end

send_body() click to toggle source

    # File lib/mongrel/http_response.rb, line 100
    def send_body
      if not @body_sent
        @body.rewind
        write(@body.read)
        @body_sent = true
      end
    end

send_file(path, small_file = false) click to toggle source

Appends the contents of `path` to the response stream. The file is opened for binary reading and written in chunks to the socket.

Sendfile API support has been removed in 0.3.13.4 due to stability problems.

    # File lib/mongrel/http_response.rb, line 112
    def send_file(path, small_file = false)
      if small_file
        File.open(path, "rb") {|f| @socket << f.read }
      else
        File.open(path, "rb") do |f|
          while chunk = f.read(Const::CHUNK_SIZE) and chunk.length > 0
            begin
              write(chunk)
            rescue Object => exc
              break
            end
          end
        end
      end
      @body_sent = true
    end

send_header() click to toggle source

    # File lib/mongrel/http_response.rb, line 92
    def send_header
      if not @header_sent
        @header.out.rewind
        write(@header.out.read + Const::LINE_END)
        @header_sent = true
      end
    end

send_status(content_length=@body.length) click to toggle source

    # File lib/mongrel/http_response.rb, line 84
    def send_status(content_length=@body.length)
      if not @status_sent
        @header['Content-Length'] = content_length if content_length and @status != 304
        write(Const::STATUS_FORMAT % [@status, @reason || HTTP_STATUS_CODES[@status]])
        @status_sent = true
      end
    end

socket_error(details) click to toggle source

    # File lib/mongrel/http_response.rb, line 129
    def socket_error(details)
      # ignore these since it means the client closed off early
      @socket.close rescue nil
      done = true
      raise details
    end

start(status=200, finalize=false, reason=nil) click to toggle source

Receives a block passing it the header and body for you to work with. When the block is finished it writes everything you've done to the socket in the proper order. This lets you intermix header and body content as needed. Handlers are able to modify pretty much any part of the request in the chain, and can stop further processing by simple passing "finalize=true" to the start method. By default all handlers run and then mongrel finalizes the request when they're all done.

    # File lib/mongrel/http_response.rb, line 62
    def start(status=200, finalize=false, reason=nil)
      @status = status.to_i
      @reason = reason
      yield @header, @body
      finished if finalize
    end

write(data) click to toggle source

    # File lib/mongrel/http_response.rb, line 136
    def write(data)
      @socket.write(data)
    rescue => details
      socket_error(details)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.