Applications now write the response body with a Writer object.

joshthecoder · joshthecoder · commit 686049dfdd60 · 2010-02-25T22:16:08.000-06:00
diff --git a/examples/hello.ooc b/examples/hello.ooc
@@ -1,21 +1,19 @@
 use web, fastcgi
 
-import io/Reader
 import text/StringBuffer
 import web/[Application]
 import fastcgi/Server
 
 
 HelloApplication: class extends Application {
-    processRequest: func -> Reader {
+    processRequest: func {
         "Request path: %s" format(request path) println()
         "Request method: %s" format(request method) println()
         "Request remote addr: %s port %d" format(request remoteAddress, request remotePort) println()
 
         response setHeader("Content-type", "text/html")
-        out := BufferReader new()
-        out buffer() append("<html><body><h1>Hello world from ooc!!!</h1></body></html>")
-        return out
+        out := response body()
+        out write("<html><body><h1>Hello world from ooc!!!</h1></body></html>")
     }
 }
 
diff --git a/examples/sendfile.ooc b/examples/sendfile.ooc
@@ -5,6 +5,7 @@ import fastcgi/Server
 import io/[Reader, FileReader]
 
 
+//TODO: update this to use the new body() writer
 SendFile: class extends Application {
     processRequest: func -> Reader {
         response setHeader("Content-type", "text/plain; charset=utf-8")
diff --git a/servers/fastcgi/fastcgi/Server.ooc b/servers/fastcgi/fastcgi/Server.ooc
@@ -1,6 +1,7 @@
 use web, fastcgi
 import web/[Server, Application]
 import fastcgi/fcgx
+import io/Writer
 
 
 /**
@@ -40,17 +41,7 @@ FCGIServer: class extends Server {
             // dispatch request to Application
             application request = request
             application response = FCGIResponse new(fcgi out)
-            responseBody := application processRequest()
-
-            // send response body
-            if (responseBody) {
-                FCGX putString("\r\n", fcgi out)
-                while (responseBody hasNext()) {
-                    if (FCGX putChar(responseBody read(), fcgi out) == -1) {
-                        Exception new(This, "Write error while sending response body!") throw()
-                    }
-                }
-            }
+            application processRequest()
         }
 
         return true
@@ -71,14 +62,47 @@ FCGIRequest: class extends Request {
 
 FCGIResponse: class extends Response {
     stream: FCGXStream*
+    bodyWriter: Writer
 
-    init: func(=stream) {}
+    init: func(=stream) { bodyWriter = null }
 
     setStatus: func(code: Int, value: String) {
+        if(bodyWriter) Exception new("May not set status code once body() has been called") throw()
         FCGX putString("Status: %d %s\r\n" format(code, value), stream)
     }
 
     setHeader: func(name: String, value: String) {
+        if(bodyWriter) Exception new("May not set header once body() has been called") throw()
         FCGX putString("%s: %s\r\n" format(name, value), stream)
     }
+
+    body: func -> Writer {
+        if (!bodyWriter) {
+            FCGX putString("\r\n", stream)  // terminate headers
+            bodyWriter = FCGIBodyWriter new(stream)
+        }
+        return bodyWriter
+    }
+}
+
+FCGIBodyWriter: class extends Writer {
+    stream: FCGXStream*
+
+    init: func(=stream) {}
+
+    close: func {}
+
+    write: func ~chr (chr: Char) {
+        if (FCGX putChar(chr, stream) == -1) {
+            Exception new("Error while sending response body byte") throw()
+        }
+    }
+
+    write: func(chars: String, length: SizeT) -> SizeT {
+        bytes := FCGX putStringWithLength(chars, length, stream)
+        if (bytes == -1) {
+            Exception new("Error while sending response body string") throw()
+        }
+        return bytes
+    }
 }
diff --git a/servers/fastcgi/fastcgi/fcgx.ooc b/servers/fastcgi/fastcgi/fcgx.ooc
@@ -27,6 +27,7 @@ FCGX: cover {
     getString: extern(FCGX_GetStr) static func(String, Int, FCGXStream*) -> Int
     getLine: extern(FCGX_GetLine) static func(String, Int, FCGXStream*) -> String
     putChar: extern(FCGX_PutChar) static func(Char, FCGXStream*) -> Int
+    putStringWithLength: extern(FCGX_PutStr) static func(String, Int, FCGXStream*) -> Int
     putString: extern(FCGX_PutS) static func(String, FCGXStream*) -> Int
     getParam: extern(FCGX_GetParam) static func(String, Pointer) -> String
 
diff --git a/web/Application.ooc b/web/Application.ooc
@@ -1,4 +1,4 @@
-import io/Reader
+import io/Writer
 
 
 Request: abstract class {
@@ -8,18 +8,40 @@ Request: abstract class {
     remoteHost: String
     remotePort: String
 
+    /**
+        Returns the value for the HTTP request header for the given key.
+    */
     getHeader: abstract func(name: String) -> String
 }
 
 Response: abstract class {
+    /**
+        Set the HTTP response status code and message.
+    */
     setStatus: abstract func(code: Int, message: String)
+
+    /**
+        Set a HTTP response header.
+    */
     setHeader: abstract func(name: String, value: String)
+
+    /**
+        Returns a writer object used for sending
+        the response body.
+
+        Note: once you call this method, not further
+        headers way be sent or the status code/message changed.
+    */
+    body: abstract func -> Writer
 }
 
 Application: abstract class {
     request: Request
     response: Response
 
-    processRequest: abstract func -> Reader
+    /**
+        Invoked by the server when ever there is a request to be processed.
+    */
+    processRequest: abstract func
 }
 
