nyara 0.0.1.pre.2 → 0.0.1.pre.3

data/ext/request.c

@@ -1,187 +1,17 @@
+/* request parsing and request object */
+
 #include "nyara.h"
 #include <ruby/encoding.h>
-#include <multipart_parser.h>
-#include <errno.h>
-#ifndef write
-#include <unistd.h>
-#endif
-
-typedef struct {
-  http_parser hparser;
-  multipart_parser* mparser;
-  enum http_method method;
-  VALUE header;
-  VALUE accept; // mime array sorted with q
-  VALUE format; // string ext without dot
-  VALUE fiber;
-  VALUE scope; // mapped prefix
-  VALUE path_with_query;
-  VALUE path;
-  VALUE query;
-  VALUE last_field;
-  VALUE last_value;
-  VALUE self;
-  int fd;
-
-  // response
-  int status;
-  VALUE response_content_type;
-  VALUE response_header;
-  VALUE response_header_extra_lines;
-} Request;
-
-// typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
-// typedef int (*http_cb) (http_parser*);
-
-static ID id_not_found;
+#include "request.h"
+
 static VALUE str_html;
 static rb_encoding* u8_encoding;
 static VALUE request_class;
-static VALUE method_override_key;
-static VALUE str_accept;
-static VALUE nyara_http_methods;
-
-static VALUE fd_request_map;
-#define MAX_RECEIVE_DATA 65536
-static char received_data[MAX_RECEIVE_DATA];
-
-static VALUE _fiber_func(VALUE _, VALUE args) {
-  VALUE instance = rb_ary_pop(args);
-  VALUE meth = rb_ary_pop(args);
-  rb_apply(instance, SYM2ID(meth), args);
-  return Qnil;
-}
-
-static void _upcase_method(VALUE str) {
-  char* s = RSTRING_PTR(str);
-  long len = RSTRING_LEN(str);
-  for (long i = 0; i < len; i++) {
-    if (s[i] >= 'a' && s[i] <= 'z') {
-      s[i] = 'A' + (s[i] - 'a');
-    }
-  }
-}
-
-static inline void _close_fd(int fd) {
-  rb_hash_delete(fd_request_map, INT2FIX(fd));
-  close(fd);
-}
-
-static int on_url(http_parser* parser, const char* s, size_t len) {
-  Request* p = (Request*)parser;
-  p->method = parser->method;
-
-  if (p->path_with_query == Qnil) {
-    p->path_with_query = rb_str_new(s, len);
-  } else {
-    rb_str_cat(p->path_with_query, s, len);
-  }
-  return 0;
-}
-
-static int on_message_complete(http_parser* parser) {
-  Request* p = (Request*)parser;
-  if (p->fiber == Qnil) {
-    return 1;
-  } else {
-    VALUE state = rb_fiber_resume(p->fiber, 0, NULL);
-    if (state == Qnil) { // terminated (todo check raise error)
-      if (p->status == 200) {
-        write(p->fd, "0\r\n\r\n", 5);
-      }
-      _close_fd(p->fd);
-      p->fd = 0;
-    } else if (SYM2ID(state) == rb_intern("term_close")) {
-      write(p->fd, "0\r\n\r\n", 5);
-      _close_fd(p->fd);
-      p->fd = 0;
-    }
-    return 0;
-  }
-}
-
-static int on_header_field(http_parser* parser, const char* s, size_t len) {
-  Request* p = (Request*)parser;
-  if (p->last_field == Qnil) {
-    p->last_field = rb_str_new(s, len);
-    p->last_value = Qnil;
-  } else {
-    rb_str_cat(p->last_field, s, len);
-  }
-  return 0;
-}
-
-static int on_header_value(http_parser* parser, const char* s, size_t len) {
-  Request* p = (Request*)parser;
-  if (p->last_field == Qnil) {
-    if (p->last_value == Qnil) {
-      rb_bug("on_header_value called when neither last_field nor last_value exist");
-      return 1;
-    }
-    rb_str_cat(p->last_value, s, len);
-  } else {
-    nyara_headerlize(p->last_field);
-    p->last_value = rb_str_new(s, len);
-    rb_hash_aset(p->header, p->last_field, p->last_value);
-    p->last_field = Qnil;
-  }
-  return 0;
-}
-
-// may override POST by _method in query
-static void _parse_path_and_query(Request* p) {
-  char* s = RSTRING_PTR(p->path_with_query);
-  long len = RSTRING_LEN(p->path_with_query);
-  long query_i = nyara_parse_path(p->path, s, len);
-  if (query_i < len) {
-    nyara_parse_param(p->query, s + query_i, len - query_i);
-
-    // do method override with _method=xxx in query
-    if (p->method == HTTP_POST) {
-      VALUE meth = rb_hash_aref(p->query, method_override_key);
-      if (TYPE(meth) == T_STRING) {
-        _upcase_method(meth);
-        VALUE meth_num = rb_hash_aref(nyara_http_methods, meth);
-        if (meth_num != Qnil) {
-          p->method = FIX2INT(meth_num);
-        }
-      }
-    }
-  }
-}
+static VALUE sym_writing;
 
-static int on_headers_complete(http_parser* parser) {
-  Request* p = (Request*)parser;
-  p->last_field = Qnil;
-  p->last_value = Qnil;
-
-  _parse_path_and_query(p);
-  p->accept = ext_parse_accept_value(Qnil, rb_hash_aref(p->header, str_accept));
-  volatile RouteResult result = nyara_lookup_route(p->method, p->path, p->accept);
-  if (RTEST(result.controller)) {
-    rb_ary_push(result.args, rb_class_new_instance(1, &(p->self), result.controller));
-    // result.args is on stack, no need to worry gc
-    p->fiber = rb_fiber_new(_fiber_func, result.args);
-    p->scope = result.scope;
-    p->format = result.format;
-    p->response_header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
-    p->response_header_extra_lines = rb_ary_new();
-    return 0;
-  }
-  rb_funcall(p->self, id_not_found, 0);
-  return 1;
-}
-
-static http_parser_settings request_settings = {
-  .on_message_begin = NULL,
-  .on_url = on_url,
-  .on_status_complete = NULL,
-  .on_header_field = on_header_field,
-  .on_header_value = on_header_value,
-  .on_headers_complete = on_headers_complete,
-  .on_body = NULL,             // data_cb
-  .on_message_complete = on_message_complete
-};
+#define P \
+  Request* p;\
+  Data_Get_Struct(self, Request, p);
 
 static void request_mark(void* pp) {
   Request* p = pp;
@@ -199,6 +29,7 @@ static void request_mark(void* pp) {
     rb_gc_mark_maybe(p->response_content_type);
     rb_gc_mark_maybe(p->response_header);
     rb_gc_mark_maybe(p->response_header_extra_lines);
+    rb_gc_mark_maybe(p->watched_fds);
   }
 }
 
@@ -206,19 +37,25 @@ static void request_free(void* pp) {
   Request* p = pp;
   if (p) {
     if (p->fd) {
-      _close_fd(p->fd);
+      nyara_detach_fd(p->fd);
     }
     xfree(p);
   }
 }
 
-static Request* request_alloc() {
+static Request* _request_alloc() {
   Request* p = ALLOC(Request);
   http_parser_init(&(p->hparser), HTTP_REQUEST);
+  p->mparser = NULL;
+
+  p->method = HTTP_GET;
+  p->fd = 0;
+  p->parse_state = 0;
+  p->status = 200;
+
   volatile VALUE header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
   volatile VALUE path = rb_enc_str_new("", 0, u8_encoding);
   volatile VALUE query = rb_class_new_instance(0, NULL, nyara_param_hash_class);
-  p->mparser = NULL;
   p->header = header;
   p->accept = Qnil;
   p->format = Qnil;
@@ -229,66 +66,36 @@ static Request* request_alloc() {
   p->query = query;
   p->last_field = Qnil;
   p->last_value = Qnil;
-  p->fd = 0;
-  p->status = 200;
   p->response_content_type = Qnil;
   p->response_header = Qnil;
   p->response_header_extra_lines = Qnil;
+
+  volatile VALUE watched_fds = rb_ary_new();
+  p->watched_fds = watched_fds;
+
   p->self = Data_Wrap_Struct(request_class, request_mark, request_free, p);
   return p;
 }
 
-static VALUE request_alloc_func(VALUE klass) {
-  return request_alloc()->self;
+VALUE nyara_request_new(int fd) {
+  Request* p = _request_alloc();
+  p->fd = fd;
+  return p->self;
 }
 
-/* client entrance
-invoke order:
-- find/create request
-- http_parser_execute
-- on_headers_complete => 404 or create request
-- on_message_complete => run action
-*/
-void nyara_handle_request(int fd) {
-  Request* p = NULL;
-  bool first_time = false;
-
-  {
-    VALUE v_fd = INT2FIX(fd);
-    VALUE request = rb_hash_aref(fd_request_map, v_fd);
-    if (request == Qnil) {
-      p = request_alloc();
-      p->fd = fd;
-      rb_hash_aset(fd_request_map, v_fd, p->self);
-      first_time = true;
-    } else {
-      Data_Get_Struct(request, Request, p);
-    }
-  }
-
-  long len = read(fd, received_data, MAX_RECEIVE_DATA);
-  if (len < 0) {
-    if (errno != EAGAIN) {
-      // todo log the bug
-      if (p->fd) {
-        _close_fd(p->fd);
-        p->fd = 0;
-      }
-    }
-  } else {
-    if (first_time && !len) {
-      // todo log this exception
-      return;
-    }
-    // note: when len == 0, means eof reached, that also informs http_parser the eof
-    http_parser_execute(&(p->hparser), &request_settings, received_data, len);
+void nyara_request_term_close(VALUE self, bool write_last_chunk) {
+  P;
+  if (write_last_chunk || p->status == 200) {
+    // usually this succeeds, while not, it doesn't matter cause we are closing it
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wunused-result"
+    write(p->fd, "0\r\n\r\n", 5);
+#   pragma GCC diagnostic pop
   }
+  nyara_detach_fd(p->fd);
+  p->fd = 0;
 }
 
-#define P \
-  Request* p;\
-  Data_Get_Struct(self, Request, p);
-
 static VALUE request_http_method(VALUE self) {
   P;
   return rb_str_new2(http_method_str(p->method));
@@ -361,50 +168,72 @@ static VALUE ext_request_set_status(VALUE _, VALUE self, VALUE n) {
   return n;
 }
 
-static VALUE ext_send_data(VALUE _, VALUE self, VALUE data) {
-  P;
-  char* buf = RSTRING_PTR(data);
-  long len = RSTRING_LEN(data);
-
+// return true if success
+static bool _send_data(int fd, const char* buf, long len) {
   while(len) {
-    long written = write(p->fd, buf, len);
-    if (written == 0)
-      return Qnil;
-    if (written == -1) {
-      if (errno == EWOULDBLOCK || errno == EAGAIN) {
-        // todo enqueue data and set state
+    long written = write(fd, buf, len);
+    if (written <= 0) {
+      if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        rb_fiber_yield(1, &sym_writing);
+      } else {
+        return false;
+      }
+    } else {
+      buf += written;
+      len -= written;
+      if (len) {
+        rb_fiber_yield(1, &sym_writing);
       }
-      return Qnil;
     }
-    buf += written;
-    len -= written;
   }
+  return true;
+}
+
+static VALUE ext_request_send_data(VALUE _, VALUE self, VALUE data) {
+  P;
+  char* buf = RSTRING_PTR(data);
+  long len = RSTRING_LEN(data);
+  _send_data(p->fd, buf, len);
   return Qnil;
 }
 
-static VALUE ext_send_chunk(VALUE _, VALUE self, VALUE str) {
+static VALUE ext_request_send_chunk(VALUE _, VALUE self, VALUE str) {
   long len = RSTRING_LEN(str);
   if (!len) {
     return Qnil;
   }
-  // todo len overflow?
   P;
-  long res = dprintf(p->fd, "%lx\r\n%.*s\r\n", len, (int)len, RSTRING_PTR(str));
-  if (res < 0) {
-    rb_raise(rb_eRuntimeError, "%s", strerror(errno));
+
+  char pre_buf[20]; // enough space to hold a long + 2 chars
+  long pre_len = sprintf(pre_buf, "%lx\r\n", len);
+  if (pre_len <= 0) {
+    rb_raise(rb_eRuntimeError, "fail to format chunk length for len: %ld", len);
+  }
+  bool success = \
+    _send_data(p->fd, pre_buf, pre_len) &&
+    _send_data(p->fd, RSTRING_PTR(str), len) &&
+    _send_data(p->fd, "\r\n", 2);
+
+  if (!success) {
+    rb_sys_fail("write(2)");
   }
+
   return Qnil;
 }
 
 // for test: find or create a request with a fd
-static VALUE ext_handle_request(VALUE _, VALUE v_fd) {
-  int fd = FIX2INT(v_fd);
-  nyara_handle_request(fd);
-  return rb_hash_aref(fd_request_map, v_fd);
+static VALUE ext_request_new(VALUE _) {
+  return _request_alloc()->self;
+}
+
+static VALUE ext_request_set_fd(VALUE _, VALUE self, VALUE vfd) {
+  P;
+  p->fd = NUM2INT(vfd);
+  return Qnil;
 }
 
 // set internal attrs in the request object
-static VALUE ext_set_request_attrs(VALUE _, VALUE self, VALUE attrs) {
+static VALUE ext_request_set_attrs(VALUE _, VALUE self, VALUE attrs) {
 # define ATTR(key) rb_hash_delete(attrs, ID2SYM(rb_intern(key)))
 # define HEADER_HASH_NEW rb_class_new_instance(0, NULL, nyara_header_hash_class)
   P;
@@ -437,22 +266,14 @@ static VALUE ext_set_request_attrs(VALUE _, VALUE self, VALUE attrs) {
 }
 
 void Init_request(VALUE nyara, VALUE ext) {
-  id_not_found = rb_intern("not_found");
   str_html = rb_str_new2("html");
   OBJ_FREEZE(str_html);
   rb_gc_register_mark_object(str_html);
   u8_encoding = rb_utf8_encoding();
-  method_override_key = rb_str_new2("_method");
-  rb_const_set(nyara, rb_intern("METHOD_OVERRIDE_KEY"), method_override_key);
-  nyara_http_methods = rb_const_get(nyara, rb_intern("HTTP_METHODS"));
-  fd_request_map = rb_hash_new();
-  rb_gc_register_mark_object(fd_request_map);
-  str_accept = rb_str_new2("Accept");
-  rb_gc_register_mark_object(str_accept);
+  sym_writing = ID2SYM(rb_intern("writing"));
 
   // request
   request_class = rb_define_class_under(nyara, "Request", rb_cObject);
-  rb_define_alloc_func(request_class, request_alloc_func);
   rb_define_method(request_class, "http_method", request_http_method, 0);
   rb_define_method(request_class, "header", request_header, 0);
   rb_define_method(request_class, "scope", request_scope, 0);
@@ -470,9 +291,10 @@ void Init_request(VALUE nyara, VALUE ext) {
 
   // hide internal methods in ext
   rb_define_singleton_method(ext, "request_set_status", ext_request_set_status, 2);
-  rb_define_singleton_method(ext, "send_data", ext_send_data, 2);
-  rb_define_singleton_method(ext, "send_chunk", ext_send_chunk, 2);
+  rb_define_singleton_method(ext, "request_send_data", ext_request_send_data, 2);
+  rb_define_singleton_method(ext, "request_send_chunk", ext_request_send_chunk, 2);
   // for test
-  rb_define_singleton_method(ext, "handle_request", ext_handle_request, 1);
-  rb_define_singleton_method(ext, "set_request_attrs", ext_set_request_attrs, 2);
+  rb_define_singleton_method(ext, "request_new", ext_request_new, 0);
+  rb_define_singleton_method(ext, "request_set_fd", ext_request_set_fd, 2);
+  rb_define_singleton_method(ext, "request_set_attrs", ext_request_set_attrs, 2);
 }

data/ext/request.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "nyara.h"
+#include <multipart_parser.h>
+#include <errno.h>
+#ifndef write
+#include <unistd.h>
+#endif
+
+enum ParseState {
+  PS_INIT, PS_HEADERS_COMPLETE, PS_MESSAGE_COMPLETE, PS_ERROR
+};
+
+typedef struct {
+  http_parser hparser;
+  multipart_parser* mparser;
+
+  enum http_method method;
+  int fd;
+  enum ParseState parse_state;
+  int status;   // response status
+
+  VALUE self;
+
+  // request
+  VALUE header;
+  VALUE accept; // mime array sorted with q
+  VALUE format; // string ext without dot
+  VALUE fiber;
+  VALUE scope;  // mapped prefix
+  VALUE path_with_query;
+  VALUE path;
+  VALUE query;
+  VALUE last_field;
+  VALUE last_value;
+
+  // response
+  VALUE response_content_type;
+  VALUE response_header;
+  VALUE response_header_extra_lines;
+
+  VALUE watched_fds;
+} Request;

data/ext/request_parse.c

@@ -0,0 +1,123 @@
+/* request parse callbacks */
+
+#include "nyara.h"
+#include "request.h"
+
+static VALUE str_accept;
+static VALUE method_override_key;
+static VALUE nyara_http_methods;
+
+static int on_url(http_parser* parser, const char* s, size_t len) {
+  Request* p = (Request*)parser;
+  p->method = parser->method;
+
+  if (p->path_with_query == Qnil) {
+    p->path_with_query = rb_str_new(s, len);
+  } else {
+    rb_str_cat(p->path_with_query, s, len);
+  }
+  return 0;
+}
+
+static int on_header_field(http_parser* parser, const char* s, size_t len) {
+  Request* p = (Request*)parser;
+  if (p->last_field == Qnil) {
+    p->last_field = rb_str_new(s, len);
+    p->last_value = Qnil;
+  } else {
+    rb_str_cat(p->last_field, s, len);
+  }
+  return 0;
+}
+
+static int on_header_value(http_parser* parser, const char* s, size_t len) {
+  Request* p = (Request*)parser;
+  if (p->last_field == Qnil) {
+    if (p->last_value == Qnil) {
+      p->parse_state = PS_ERROR;
+      return 1;
+    }
+    rb_str_cat(p->last_value, s, len);
+  } else {
+    nyara_headerlize(p->last_field);
+    p->last_value = rb_str_new(s, len);
+    rb_hash_aset(p->header, p->last_field, p->last_value);
+    p->last_field = Qnil;
+  }
+  return 0;
+}
+
+static void _upcase_method(VALUE str) {
+  char* s = RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+  for (long i = 0; i < len; i++) {
+    if (s[i] >= 'a' && s[i] <= 'z') {
+      s[i] = 'A' + (s[i] - 'a');
+    }
+  }
+}
+
+// may override POST by _method in query
+static void _parse_path_and_query(Request* p) {
+  char* s = RSTRING_PTR(p->path_with_query);
+  long len = RSTRING_LEN(p->path_with_query);
+  long query_i = nyara_parse_path(p->path, s, len);
+  if (query_i < len) {
+    nyara_parse_param(p->query, s + query_i, len - query_i);
+
+    // do method override with _method=xxx in query
+    if (p->method == HTTP_POST) {
+      VALUE meth = rb_hash_aref(p->query, method_override_key);
+      if (TYPE(meth) == T_STRING) {
+        _upcase_method(meth);
+        VALUE meth_num = rb_hash_aref(nyara_http_methods, meth);
+        if (meth_num != Qnil) {
+          p->method = FIX2INT(meth_num);
+        }
+      }
+    }
+  }
+}
+
+static int on_headers_complete(http_parser* parser) {
+  Request* p = (Request*)parser;
+  p->last_field = Qnil;
+  p->last_value = Qnil;
+
+  _parse_path_and_query(p);
+  p->accept = ext_parse_accept_value(Qnil, rb_hash_aref(p->header, str_accept));
+  p->parse_state = PS_HEADERS_COMPLETE;
+  return 0;
+}
+
+static int on_body(http_parser* parser, const char* s, size_t len) {
+  // todo
+  return 0;
+}
+
+static int on_message_complete(http_parser* parser) {
+  Request* p = (Request*)parser;
+  p->parse_state = PS_MESSAGE_COMPLETE;
+  return 0;
+}
+
+// used in event.c
+http_parser_settings nyara_request_parse_settings = {
+  .on_message_begin = NULL,
+  .on_url = on_url,
+  .on_status_complete = NULL,
+  .on_header_field = on_header_field,
+  .on_header_value = on_header_value,
+  .on_headers_complete = on_headers_complete,
+  .on_body = on_body,
+  .on_message_complete = on_message_complete
+};
+
+void Init_request_parse(VALUE nyara) {
+  str_accept = rb_str_new2("Accept");
+  rb_gc_register_mark_object(str_accept);
+  method_override_key = rb_str_new2("_method");
+  OBJ_FREEZE(method_override_key);
+  rb_const_set(nyara, rb_intern("METHOD_OVERRIDE_KEY"), method_override_key);
+  nyara_http_methods = rb_const_get(nyara, rb_intern("HTTP_METHODS"));
+}

data/ext/route.cc

@@ -1,3 +1,5 @@
+/* route register and search */
+
 extern "C" {
 #include "nyara.h"
 }