0
@@ -45,34 +45,27 @@ module Ebb
0
   end
0
   
0
   def self.process(app, client)
0
-    begin
0
-      status, headers, body = app.call(client.env)
0
-    rescue
0
-      raise if $DEBUG
0
-      status = 500
0
-      headers = {'Content-Type' => 'text/plain'}
0
-      body = "Internal Server Error\n"
0
-    end
0
+    status, headers, body = app.call(client.env)
0
     
0
+    # Write the status
0
     client.write_status(status)
0
     
0
+    # Add Content-Length to the headers.
0
     if headers.respond_to?(:[]=) and body.respond_to?(:length) and status != 304
0
       headers['Connection'] = 'close'
0
       headers['Content-Length'] = body.length.to_s
0
     end
0
     
0
+    # Write the headers
0
     headers.each { |field, value| client.write_header(field, value) }
0
-    client.write("\r\n")
0
     
0
+    # Write the body
0
     if body.kind_of?(String)
0
-      client.write(body)
0
-      client.body_written()
0
-      client.begin_transmission()
0
+      client.write_body(body)
0
     else
0
-      client.begin_transmission()
0
-      body.each { |p| client.write(p) }
0
-      client.body_written()
0
+      body.each { |p| client.write_body(p) }
0
     end
0
+    
0
   rescue => e
0
     log.puts "Ebb Error! #{e.class}  #{e.message}"
0
     log.puts e.backtrace.join("\n")
0
@@ -117,8 +110,8 @@ module Ebb
0
       FFI::client_write_status(self, s, HTTP_STATUS_CODES[s])
0
     end
0
     
0
-    def write(data)
0
-      FFI::client_write(self, data)
0
+    def write_body(data)
0
+      FFI::client_write_body(self, data)
0
     end
0
     
0
     def write_header(field, value)
0
@@ -127,14 +120,6 @@ module Ebb
0
       end
0
     end
0
     
0
-    def body_written
0
-      FFI::client_set_body_written(self, true)
0
-    end
0
-    
0
-    def begin_transmission
0
-      FFI::client_begin_transmission(self)
0
-    end
0
-    
0
     def release
0
       FFI::client_release(self)
0
     end

0
@@ -282,6 +282,58 @@ error:
0
   ebb_client_close(client);
0
 }
0
 
0
+
0
+static void on_client_writable(struct ev_loop *loop, ev_io *watcher, int revents)
0
+{
0
+  ebb_client *client = (ebb_client*)(watcher->data);
0
+  ssize_t sent;
0
+  
0
+  if(client->status_written == FALSE || client->headers_written == FALSE) {
0
+    g_message("no status or headers - closing connection.");
0
+    goto error;
0
+  }
0
+  
0
+  if(EV_ERROR & revents) {
0
+    g_message("on_client_writable() got error event, closing peer");
0
+    goto error;
0
+  }
0
+  
0
+  //if(client->written != 0)
0
+  //  g_debug("total written: %d", (int)(client->written));
0
+  
0
+  sent = send( client->fd
0
+             , client->response_buffer->str + sizeof(gchar)*(client->written)
0
+             , client->response_buffer->len - client->written
0
+             , 0
0
+             );
0
+  if(sent < 0) {
0
+#ifdef DEBUG
0
+    g_message("Error writing: %s", strerror(errno));
0
+#endif
0
+    goto error;
0
+  } else if(sent == 0) {
0
+    /* is this the wrong thing to do? */
0
+    g_message("Sent zero bytes? Closing connection");
0
+    goto error;
0
+  }
0
+  client->written += sent;
0
+  
0
+  assert(client->written <= client->response_buffer->len);
0
+  //g_message("wrote %d bytes. total: %d", (int)sent, (int)(client->written));
0
+  
0
+  ev_timer_again(loop, &(client->timeout_watcher));
0
+  
0
+  if(client->written == client->response_buffer->len) {
0
+    ev_io_stop(loop, watcher);
0
+    if(client->body_written)
0
+      ebb_client_close(client);
0
+  }
0
+  return;
0
+error:
0
+  ebb_client_close(client);
0
+}
0
+
0
+
0
 static client_init(ebb_server *server, ebb_client *client)
0
 {
0
   assert(client->in_use == FALSE);
0
@@ -330,9 +382,15 @@ static client_init(ebb_server *server, ebb_client *client)
0
   client->status_written = FALSE;
0
   client->headers_written = FALSE;
0
   client->body_written = FALSE;
0
-  client->began_transmission = FALSE;
0
+  client->written = 0;
0
   
0
   /* SETUP READ AND TIMEOUT WATCHERS */
0
+  client->write_watcher.data = client;
0
+  ev_init (&client->write_watcher, on_client_writable);
0
+  ev_io_set (&client->write_watcher, client->fd, EV_WRITE | EV_ERROR);
0
+  /* Note, do not start write_watcher until there is something to be written.
0
+   * See ebb_client_write_body() */
0
+  
0
   client->read_watcher.data = client;
0
   ev_init(&client->read_watcher, on_client_readable);
0
   ev_io_set(&client->read_watcher, client->fd, EV_READ | EV_ERROR);
0
@@ -520,6 +578,7 @@ void ebb_client_release(ebb_client *client)
0
 {
0
   assert(client->in_use);
0
   client->in_use = FALSE;
0
+  client->body_written = TRUE;
0
   if(client->written == client->response_buffer->len)
0
     ebb_client_close(client);
0
 }
0
@@ -550,53 +609,6 @@ void ebb_client_close(ebb_client *client)
0
 }
0
 
0
 
0
-static void on_client_writable(struct ev_loop *loop, ev_io *watcher, int revents)
0
-{
0
-  ebb_client *client = (ebb_client*)(watcher->data);
0
-  ssize_t sent;
0
-  
0
-  assert(client->status_written);
0
-  assert(client->headers_written);
0
-  assert(client->began_transmission);
0
-  
0
-  if(EV_ERROR & revents) {
0
-    g_message("on_client_writable() got error event, closing peer");
0
-    ebb_client_close(client);
0
-    return;
0
-  }
0
-  
0
-  //if(client->written != 0)
0
-  //  g_debug("total written: %d", (int)(client->written));
0
-  
0
-  sent = send( client->fd
0
-             , client->response_buffer->str + sizeof(gchar)*(client->written)
0
-             , client->response_buffer->len - client->written
0
-             , 0
0
-             );
0
-  if(sent < 0) {
0
-#ifdef DEBUG
0
-    g_message("Error writing: %s", strerror(errno));
0
-#endif
0
-    ebb_client_close(client);
0
-    return;
0
-  } else if(sent == 0) {
0
-    g_message("Sent zero bytes? Closing connection");
0
-    ebb_client_close(client);
0
-  }
0
-  client->written += sent;
0
-  
0
-  assert(client->written <= client->response_buffer->len);
0
-  //g_message("wrote %d bytes. total: %d", (int)sent, (int)(client->written));
0
-  
0
-  ev_timer_again(loop, &(client->timeout_watcher));
0
-  
0
-  if(client->written == client->response_buffer->len) {
0
-    ev_io_stop(loop, watcher);
0
-    if(client->body_written)
0
-      ebb_client_close(client);
0
-  }
0
-}
0
-
0
 void ebb_client_write_status(ebb_client *client, int status, const char *human_status)
0
 {
0
   assert(client->in_use);
0
@@ -623,39 +635,29 @@ void ebb_client_write_header(ebb_client *client, const char *field, const char *
0
                         );
0
 }
0
 
0
-void ebb_client_write(ebb_client *client, const char *data, int length)
0
-{
0
-  assert(client->in_use);
0
-  if(!client->open) return;
0
-  g_string_append_len(client->response_buffer, data, length);
0
-  if(client->began_transmission) {
0
-    /* restart the watcher if we're streaming */
0
-    ev_io_start(client->server->loop, &client->write_watcher);
0
-  }
0
-}
0
-
0
 
0
-void ebb_client_begin_transmission(ebb_client *client)
0
+void ebb_client_write_body(ebb_client *client, const char *data, int length)
0
 {
0
   assert(client->in_use);
0
   if(!client->open) return;
0
-  assert(FALSE == ev_is_active(&client->write_watcher));
0
   
0
-  /* assure the socket is still in non-blocking mode */
0
-  int flags = fcntl(client->fd, F_GETFL, 0);
0
-  if(0 > fcntl(client->fd, F_SETFL, flags | O_NONBLOCK)) {
0
-    perror("fcntl()");
0
-    ebb_client_close(client);
0
-    return;
0
+  if(client->headers_written == FALSE) {
0
+    g_string_append(client->response_buffer, "\r\n");
0
   }
0
   
0
-  client->headers_written = TRUE;
0
-  client->began_transmission = TRUE;
0
-  client->written = 0;
0
-  client->write_watcher.data = client;
0
-  ev_init (&(client->write_watcher), on_client_writable);
0
-  ev_io_set (&(client->write_watcher), client->fd, EV_WRITE | EV_ERROR);
0
-  ev_io_start(client->server->loop, &client->write_watcher);
0
+  g_string_append_len(client->response_buffer, data, length);
0
+  
0
+  /* If the write_watcher isn't yet active, then start it. It could be that
0
+   * we're streaming and the watcher has been stopped. In that case we 
0
+   * start it again since we have more to write. */
0
+  if(ev_is_active(&client->write_watcher) == FALSE) {
0
+    /* assure the socket is still in non-blocking mode */
0
+    int flags = fcntl(client->fd, F_GETFL, 0);
0
+    if(0 > fcntl(client->fd, F_SETFL, flags | O_NONBLOCK))
0
+      perror("fcntl() setting non-block");
0
+    client->headers_written = TRUE;
0
+    ev_io_start(client->server->loop, &client->write_watcher);
0
+  }
0
 }
0
 
0
 

0
@@ -15,7 +15,7 @@ typedef struct ebb_server ebb_server;
0
 typedef struct ebb_client ebb_client;
0
 #define EBB_VERSION "0.1.0"
0
 #define EBB_BUFFERSIZE (1024 * (80 + 33))
0
-#define EBB_MAX_CLIENTS 200
0
+#define EBB_MAX_CLIENTS 1024
0
 #define EBB_TIMEOUT 30.0
0
 #define EBB_MAX_ENV 500
0
 #define EBB_TCP_COMMON          \
0
@@ -30,7 +30,8 @@ void ebb_client_release(ebb_client*);
0
 int ebb_client_read(ebb_client *client, char *buffer, int length);
0
 void ebb_client_write_status(ebb_client*, int status, const char *human_status);
0
 void ebb_client_write_header(ebb_client*, const char *field, const char *value);
0
-void ebb_client_write(ebb_client*, const char *data, int length);
0
+void ebb_client_write_body(ebb_client*, const char *data, int length);
0
+
0
 void ebb_client_begin_transmission( ebb_client *client);
0
 
0
 struct ebb_env_item {
0
@@ -76,7 +77,6 @@ struct ebb_client {
0
   unsigned int status_written : 1;
0
   unsigned int headers_written : 1;
0
   unsigned int body_written : 1;
0
-  unsigned int began_transmission : 1;
0
   
0
   /* the ENV structure */
0
   int env_size;

0
@@ -213,25 +213,15 @@ VALUE client_write_header(VALUE _, VALUE client, VALUE field, VALUE value)
0
   return Qnil;
0
 }
0
 
0
-VALUE client_write(VALUE _, VALUE client, VALUE string)
0
+VALUE client_write_body(VALUE _, VALUE client, VALUE string)
0
 {
0
   ebb_client *_client;
0
   Data_Get_Struct(client, ebb_client, _client);
0
-  ebb_client_write(_client, RSTRING_PTR(string), RSTRING_LEN(string));
0
+  ebb_client_write_body(_client, RSTRING_PTR(string), RSTRING_LEN(string));
0
   return Qnil;
0
 }
0
 
0
 
0
-VALUE client_begin_transmission(VALUE _, VALUE rb_client)
0
-{
0
-  ebb_client *client;
0
-  Data_Get_Struct(rb_client, ebb_client, client);
0
-  client->status_written = TRUE;
0
-  client->headers_written = TRUE;
0
-  ebb_client_begin_transmission(client);
0
-  return Qnil;
0
-}
0
-
0
 VALUE client_release(VALUE _, VALUE rb_client)
0
 {
0
   ebb_client *client;
0
@@ -241,14 +231,6 @@ VALUE client_release(VALUE _, VALUE rb_client)
0
 }
0
 
0
 
0
-VALUE client_set_body_written(VALUE _, VALUE rb_client, VALUE v)
0
-{
0
-  ebb_client *client;
0
-  Data_Get_Struct(rb_client, ebb_client, client);
0
-  client->body_written = RTEST(v);
0
-  return client->body_written ? Qtrue : Qfalse;
0
-}
0
-
0
 void Init_ebb_ext()
0
 {
0
   VALUE mEbb = rb_define_module("Ebb");
0
@@ -280,9 +262,7 @@ void Init_ebb_ext()
0
   rb_define_singleton_method(mFFI, "client_read_input", client_read_input, 2);
0
   rb_define_singleton_method(mFFI, "client_write_status", client_write_status, 3);
0
   rb_define_singleton_method(mFFI, "client_write_header", client_write_header, 3);
0
-  rb_define_singleton_method(mFFI, "client_write", client_write, 2);
0
-  rb_define_singleton_method(mFFI, "client_begin_transmission", client_begin_transmission, 1);
0
-  rb_define_singleton_method(mFFI, "client_set_body_written", client_set_body_written, 2);
0
+  rb_define_singleton_method(mFFI, "client_write_body", client_write_body, 2);
0
   rb_define_singleton_method(mFFI, "client_env", client_env, 1);
0
   rb_define_singleton_method(mFFI, "client_release", client_release, 1);
0