nyara 0.0.1.pre.9 → 0.1.pre.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abcd7918ded6547e4edadb0746742a854f3c216b
-  data.tar.gz: 8dfaf81082c63b6e117bfc6836210d3d6f8f9aa8
+  metadata.gz: 8488241a4b245171cf578a271e64cde4bcb5e992
+  data.tar.gz: 157848c9c7f726ebc67fbb9f63fb823274ed2312
 SHA512:
-  metadata.gz: 00c038fe5d84059b5452c8f445e0680c95f05a81be846c73a481efe0fd1a2d50433f3511b04453187983e6fd491940c7033229757d10d5da52c91fd508c332e8
-  data.tar.gz: 8a49ba878195450a06fe361c3d0ac57697c89f508b2c8f4ba5bb0e5a0acbcd8ff2f287cf59f38d63df4633af17c055b98ea1d6d02623318a81098b55a8b4b7b1
+  metadata.gz: dfc38bc4139cdae9178f69db59bffc2fa46867bb40864e8c1df13f80ca9a95707795ed2a48c9a4b3cc2c248726571cfbff062d515c2bf113095d5deafc89003f
+  data.tar.gz: 9d40524878b0ca0ba9d1606c9ad4f4336dc51ac042946fc53b04285dfbc8625248629522d1497cd36a1e9d95d4c4e00b8646ce0d84d8e936264bf7ca53a5eecd

data/bin/nyara

@@ -6,12 +6,12 @@ task_name = args.shift || 'help'
 
 
 case task_name
-when 'help'
-  Nyara::Command.help
-when '-h'
+when 'help', '-h'
   Nyara::Command.help
 when '-v'
   Nyara::Command.version
 when 'new'
   Nyara::Command.new_project(*args)
+when 's','server'
+  Nyara::Command.run_server(*args)
 end

data/changes

@@ -1,3 +1,4 @@
+2013-07-18 add automatic reloader for development mode
 2013-07-13 add bin script `nyara`
 2013-07-10 add before filter
 2013-07-06 add worker signal management

data/ext/event.c

@@ -46,9 +46,14 @@ static Request* curr_request;
 static bool graceful_quit = false;
 
 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);
+  static VALUE controller_class = Qnil;
+  static ID id_dispatch;
+  if (controller_class == Qnil) {
+    controller_class = rb_const_get(rb_cModule, rb_intern("Nyara"));
+    controller_class = rb_const_get(controller_class, rb_intern("Controller"));
+    id_dispatch = rb_intern("dispatch");
+  }
+  rb_apply(controller_class, id_dispatch, args);
   return Qnil;
 }
 
@@ -102,27 +107,16 @@ static void _handle_request(VALUE request) {
   // ensure action
   if (p->fiber == Qnil) {
     volatile RouteResult result = nyara_lookup_route(p->method, p->path, p->accept);
-    nyara_summary_request(p->method, p->path, result.controller);
     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->instance = RARRAY_PTR(result.args)[RARRAY_LEN(result.args) - 1];
-      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();
-      nyara_request_init_env(request);
-    } else {
-      static const char* not_found = "HTTP/1.1 404 Not Found\r\nConnection: close\r\nContent-Length: 0\r\n\r\n";
-      static long not_found_len = 0;
-      if (!not_found_len) {
-        not_found_len = strlen(not_found);
-      }
-      nyara_send_data(p->fd, not_found, not_found_len);
-      nyara_detach_rid(p->rid);
-      return;
+      p->instance = rb_class_new_instance(1, &(p->self), result.controller);
     }
+    // result.args is on stack, no need to worry gc
+    p->scope = result.scope;
+    p->format = result.format;
+    p->cookie = rb_class_new_instance(0, NULL, nyara_param_hash_class);
+    p->response_header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
+    p->response_header_extra_lines = rb_ary_new();
+    p->fiber = rb_fiber_new(_fiber_func, rb_ary_new3(3, p->self, p->instance, result.args));
   }
 
   _resume_action(p);

data/ext/hashes.c

@@ -3,18 +3,19 @@
 #include "nyara.h"
 #include <ruby/st.h>
 #include "inc/str_intern.h"
+#include <ctype.h>
 
 VALUE nyara_param_hash_class;
 VALUE nyara_header_hash_class;
 VALUE nyara_config_hash_class;
 
 // stolen from hash.c
-int nyara_rb_hash_has_key(VALUE hash, VALUE key) {
+static bool nyara_rb_hash_has_key(VALUE hash, VALUE key) {
   if (!RHASH(hash)->ntbl)
-    return 0;
+    return false;
   if (st_lookup(RHASH(hash)->ntbl, key, 0))
-    return 1;
-  return 0;
+    return true;
+  return false;
 }
 
 // NOTE no need to add lots of methods like HashWithIndifferentAccess
@@ -41,6 +42,219 @@ static VALUE param_hash_aset(VALUE self, VALUE key, VALUE value) {
   return rb_hash_aset(self, key, value);
 }
 
+// prereq: name should be already url decoded <br>
+// "a[b][][c]" ==> ["a", "b", "", "c"]
+static VALUE param_hash_split_name(VALUE _, VALUE name) {
+  Check_Type(name, T_STRING);
+  long len = RSTRING_LEN(name);
+  if (len == 0) {
+    rb_raise(rb_eArgError, "name should not be empty");
+  }
+  char* s = RSTRING_PTR(name);
+
+  // NOTE it's OK to compare utf-8 string with ascii chars, because utf-8 code units are either:
+  // - byte with 0 in highest nibble, which is ascii char
+  // - bytes with 1 in highest nibble, which can not be eql to any ascii char
+
+  volatile VALUE keys = rb_ary_new();
+  long i;
+  for (i = 0; i < len; i++) {
+    if (s[i] == '[') {
+      if (i == 0) {
+        rb_raise(rb_eArgError, "bad name (starts with '[')");
+      }
+      volatile VALUE key = rb_enc_str_new(s, i, u8_encoding);
+      rb_ary_push(keys, key);
+      i++;
+      break;
+    } else if (s[i] == ']') {
+      rb_raise(rb_eArgError, "bad name (unmatched ']')");
+    }
+  }
+
+  if (RARRAY_LEN(keys)) {
+    if (s[len - 1] != ']') {
+      rb_raise(rb_eArgError, "bad name (not end with ']')");
+    }
+    long last_j = i;
+    for (long j = last_j; j < len; j++) {
+      if (s[j] == ']') {
+        if (j == len - 1 || s[j + 1] == '[') {
+          volatile VALUE key = rb_enc_str_new(s + last_j, j - last_j, u8_encoding);
+          rb_ary_push(keys, key);
+          last_j = j + 2; // fine for last round
+          j++;
+        } else {
+          rb_raise(rb_eArgError, "bad name (']' not followed by '[')");
+        }
+      } else if (s[j] == '[') {
+        rb_raise(rb_eArgError, "bad name (nested '[')");
+      }
+    }
+  } else {
+    // single key
+    rb_ary_push(keys, name);
+  }
+  return keys;
+}
+
+// assume keys = [a, b, c] ==> self[a][b][c] = value
+// blank keys will be translated as array keys.
+// created hashes has the same class with output
+// todo make 2 versions, one for public use
+static VALUE param_hash_nested_aset(VALUE output, volatile VALUE keys, VALUE value) {
+  Check_Type(keys, T_ARRAY);
+  VALUE* arr = RARRAY_PTR(keys);
+  long len = RARRAY_LEN(keys);
+  if (!len) {
+    rb_raise(rb_eArgError, "aset 0 length key");
+    return Qnil;
+  }
+  volatile VALUE klass = rb_obj_class(output);
+
+  // first key seg
+  long is_hash_key = 1;
+
+  // middle key segs
+  for (long i = 0; i < len - 1; i++) {
+    long next_is_hash_key = RSTRING_LEN(arr[i + 1]);
+#   define NEW_CHILD(child) \
+      volatile VALUE child = (next_is_hash_key ? rb_class_new_instance(0, NULL, klass) : rb_ary_new());
+
+    if (is_hash_key) {
+      if (nyara_rb_hash_has_key(output, arr[i])) {
+        output = rb_hash_aref(output, arr[i]);
+        if (next_is_hash_key) {
+          if (TYPE(output) != T_HASH) {
+            rb_raise(rb_eRuntimeError, "hash key at:%ld conflicts with array", i + 1);
+          }
+        } else {
+          if (TYPE(output) != T_ARRAY) {
+            rb_raise(rb_eRuntimeError, "array key at:%ld conflicts with hash", i + 1);
+          }
+        }
+      } else {
+        NEW_CHILD(child);
+        rb_hash_aset(output, arr[i], child);
+        output = child;
+      }
+    } else {
+      NEW_CHILD(child);
+      rb_ary_push(output, child);
+      output = child;
+    }
+    is_hash_key = next_is_hash_key;
+#   undef NEW_CHILD
+  }
+
+  // terminate key seg: add value
+  if (is_hash_key) {
+    rb_hash_aset(output, arr[len - 1], value);
+  } else {
+    rb_ary_push(output, value);
+  }
+  return output;
+}
+
+// s, len is the raw kv string
+// returns trailing length
+static void _kv(VALUE output, const char* s, long len, bool nested_mode) {
+  // strip
+  for (; len > 0; len--, s++) {
+    if (!isspace(*s)) {
+      break;
+    }
+  }
+  for (; len > 0; len--) {
+    if (!isspace(s[len - 1])) {
+      break;
+    }
+  }
+  if (len > 0) {
+    volatile VALUE key = rb_enc_str_new("", 0, u8_encoding);
+    volatile VALUE value = rb_enc_str_new("", 0, u8_encoding);
+    nyara_decode_uri_kv(key, value, s, len);
+    if (nested_mode) {
+      volatile VALUE keys = param_hash_split_name(Qnil, key);
+      param_hash_nested_aset(output, keys, value);
+    } else {
+      rb_hash_aset(output, key, value);
+    }
+  }
+}
+
+// class method:
+// insert parsing result into output
+static VALUE param_hash_parse_cookie(VALUE _, VALUE output, VALUE str) {
+  Check_Type(output, T_HASH);
+  Check_Type(str, T_STRING);
+  if (rb_obj_is_kind_of(output, nyara_header_hash_class)) {
+    rb_raise(rb_eArgError, "can not parse cookie into HeaderHash");
+  }
+  const char* s = RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+
+  // split with /[,;]/
+  // scan in reverse order because entries on the left of the cookie has greater priority
+  long i = len - 1;
+  long last_i = i;
+  for (; i >= 0; i--) {
+    if (s[i] == ',' || s[i] == ';') {
+      if (i < last_i) {
+        _kv(output, s + i + 1, last_i - i, false);
+      }
+      last_i = i - 1;
+    }
+  }
+  if (last_i > 0) {
+    _kv(output, s, last_i + 1, false);
+  }
+  return output;
+}
+
+// class method:
+// insert parsing result into output
+static VALUE param_hash_parse_param(VALUE _, VALUE output, VALUE str) {
+  Check_Type(output, T_HASH);
+  Check_Type(str, T_STRING);
+  if (rb_obj_is_kind_of(output, nyara_header_hash_class)) {
+    rb_raise(rb_eArgError, "can not parse param into HeaderHash");
+  }
+  const char* s = RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+
+  // split with /[&;]/
+  long i = 0;
+  long last_i = i;
+  for (; i < len; i++) {
+    if (s[i] == '&' || s[i] == ';') {
+      if (i > last_i) {
+        _kv(output, s + last_i, i - last_i, true);
+      }
+      last_i = i + 1;
+    }
+  }
+  if (i > last_i) {
+    _kv(output, s + last_i, i - last_i, true);
+  }
+  return output;
+}
+
+static VALUE _tmp_str;
+
+static VALUE _parse_query_func(VALUE output) {
+  param_hash_parse_param(Qnil, output, _tmp_str);
+  return Qnil;
+}
+
+// do not raise error
+void nyara_parse_query(VALUE output, const char* s, long len) {
+  volatile VALUE str = rb_str_new(s, len);
+  _tmp_str = str;
+  int err = 0;
+  rb_protect(_parse_query_func, output, &err);
+}
+
 void nyara_headerlize(VALUE str) {
   char* s = (char*)RSTRING_PTR(str);
   long len = RSTRING_LEN(str);
@@ -149,6 +363,10 @@ void Init_hashes(VALUE nyara) {
   rb_define_method(nyara_param_hash_class, "[]", param_hash_aref, 1);
   rb_define_method(nyara_param_hash_class, "key?", param_hash_key_p, 1);
   rb_define_method(nyara_param_hash_class, "[]=", param_hash_aset, 2);
+  rb_define_method(nyara_param_hash_class, "nested_aset", param_hash_nested_aset, 2);
+  rb_define_singleton_method(nyara_param_hash_class, "split_name", param_hash_split_name, 1);
+  rb_define_singleton_method(nyara_param_hash_class, "parse_param", param_hash_parse_param, 2);
+  rb_define_singleton_method(nyara_param_hash_class, "parse_cookie", param_hash_parse_cookie, 2);
 
   rb_define_method(nyara_header_hash_class, "[]", header_hash_aref, 1);
   rb_define_method(nyara_header_hash_class, "key?", header_hash_key_p, 1);

data/ext/inc/rdtsc.h

@@ -0,0 +1,56 @@
+#ifndef __RDTSC_H_DEFINED__
+#define __RDTSC_H_DEFINED__
+
+
+#if defined(__i386__)
+
+static __inline__ unsigned long long rdtsc(void)
+{
+  unsigned long long int x;
+     __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
+     return x;
+}
+#elif defined(__x86_64__)
+
+static __inline__ unsigned long long rdtsc(void)
+{
+  unsigned hi, lo;
+  __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+  return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+}
+
+#elif defined(__powerpc__)
+
+static __inline__ unsigned long long rdtsc(void)
+{
+  unsigned long long int result=0;
+  unsigned long int upper, lower,tmp;
+  __asm__ volatile(
+                "0:                  \n"
+                "\tmftbu   %0           \n"
+                "\tmftb    %1           \n"
+                "\tmftbu   %2           \n"
+                "\tcmpw    %2,%0        \n"
+                "\tbne     0b         \n"
+                : "=r"(upper),"=r"(lower),"=r"(tmp)
+                );
+  result = upper;
+  result = result<<32;
+  result = result|lower;
+
+  return(result);
+}
+
+#else
+
+#error "No tick counter is available!"
+
+#endif
+
+
+/*  $RCSfile:  $   $Author: kazutomo $
+ *  $Revision: 1.6 $  $Date: 2005/04/13 18:49:58 $
+ */
+
+#endif
+

data/ext/inc/status_codes.inc

@@ -0,0 +1,64 @@
+#define HTTP_STATUS_CODES(XX)\
+  XX(100, "Continue");\
+  XX(101, "Switching Protocols");\
+  XX(102, "Processing");\
+  XX(200, "OK");\
+  XX(201, "Created");\
+  XX(202, "Accepted");\
+  XX(203, "Non-Authoritative Information");\
+  XX(204, "No Content");\
+  XX(205, "Reset Content");\
+  XX(206, "Partial Content");\
+  XX(207, "Multi-Status");\
+  XX(208, "Already Reported");\
+  XX(226, "IM Used");\
+  XX(300, "Multiple Choices");\
+  XX(301, "Moved Permanently");\
+  XX(302, "Found");\
+  XX(303, "See Other");\
+  XX(304, "Not Modified");\
+  XX(305, "Use Proxy");\
+  XX(306, "Reserved");\
+  XX(307, "Temporary Redirect");\
+  XX(308, "Permanent Redirect");\
+  XX(400, "Bad Request");\
+  XX(401, "Unauthorized");\
+  XX(402, "Payment Required");\
+  XX(403, "Forbidden");\
+  XX(404, "Not Found");\
+  XX(405, "Method Not Allowed");\
+  XX(406, "Not Acceptable");\
+  XX(407, "Proxy Authentication Required");\
+  XX(408, "Request Timeout");\
+  XX(409, "Conflict");\
+  XX(410, "Gone");\
+  XX(411, "Length Required");\
+  XX(412, "Precondition Failed");\
+  XX(413, "Request Entity Too Large");\
+  XX(414, "Request-URI Too Long");\
+  XX(415, "Unsupported Media Type");\
+  XX(416, "Requested Range Not Satisfiable");\
+  XX(417, "Expectation Failed");\
+  XX(422, "Unprocessable Entity");\
+  XX(423, "Locked");\
+  XX(424, "Failed Dependency");\
+  XX(425, "Unassigned");\
+  XX(426, "Upgrade Required");\
+  XX(427, "Unassigned");\
+  XX(428, "Precondition Required");\
+  XX(429, "Too Many Requests");\
+  XX(430, "Unassigned");\
+  XX(431, "Request Header Fields Too Large");\
+  XX(500, "Internal Server Error");\
+  XX(501, "Not Implemented");\
+  XX(502, "Bad Gateway");\
+  XX(503, "Service Unavailable");\
+  XX(504, "Gateway Timeout");\
+  XX(505, "HTTP Version Not Supported");\
+  XX(506, "Variant Also Negotiates (Experimental)");\
+  XX(507, "Insufficient Storage");\
+  XX(508, "Loop Detected");\
+  XX(509, "Unassigned");\
+  XX(510, "Not Extended");\
+  XX(511, "Network Authentication Required");\
+// end define