nyara 0.0.1.pre.3 → 0.0.1.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52583810c7afb74e920b0da7336e82441471ab82
-  data.tar.gz: 6fbd035f24bbd10ad1ade4ffdfce186e3a0d779f
+  metadata.gz: 7dc7b625bcf917f1fc957ca42953345df87faa40
+  data.tar.gz: f7c7669fed83475cb1626dec024e30eed7cf76ee
 SHA512:
-  metadata.gz: 7a3abf537a5027658497d171a5a593153316e60214b81c80f4f93c1e0557478f7473136b5cec6fc0daa76eedbb7650b01a284c72098a3069fa95bffd18ec468a
-  data.tar.gz: 8c5031033482180d9e0c1b3a4e541274abb562de5b1d04e81855c7ca556c7fcc44415abcf06a694b001f1c6a8dbd273509490a8ba45f3c58a0cf595921d92731
+  metadata.gz: e76227e8c9e4f4dc292b32e1cc72e11525e91a5b6f54784d4f7f6a63fba4b126f5fea81070cf793723908d82182faac1e3a47d3835903a99426fb82cb85e93b1
+  data.tar.gz: 592183cbad4bb90c3090a752832a2e7d26138e07b38bf2e7cb94544046619c3f6f620c566e21119f80f8c99c0f360c0be49f0303b51b19b6ac25a0c4a564c407

data/ext/event.c

@@ -21,6 +21,7 @@ static void loop_body(int fd, int etype);
 static int qfd;
 
 #define MAX_RECEIVE_DATA 65536
+// * 4
 static char received_data[MAX_RECEIVE_DATA];
 extern http_parser_settings nyara_request_parse_settings;
 
@@ -36,6 +37,7 @@ static ID id_not_found;
 static VALUE sym_term_close;
 static VALUE sym_writing;
 static VALUE sym_reading;
+static VALUE sym_sleep;
 static Request* curr_request;
 
 static void _set_nonblock(int fd) {
@@ -59,6 +61,9 @@ static VALUE _fiber_func(VALUE _, VALUE args) {
 static void _handle_request(VALUE request) {
   Request* p;
   Data_Get_Struct(request, Request, p);
+  if (p->sleeping) {
+    return;
+  }
   curr_request = p;
 
   // read and parse data
@@ -115,8 +120,8 @@ static void _handle_request(VALUE request) {
     // do nothing
   } else if (state == sym_reading) {
     // do nothing
-  } else {
-    // double value: sleep
+  } else if (state == sym_sleep) {
+    // do nothing
   }
 }
 
@@ -178,6 +183,34 @@ static VALUE ext_run_queue(VALUE _, VALUE v_fd) {
   return Qnil;
 }
 
+static VALUE ext_request_sleep(VALUE _, VALUE request) {
+  Request* p;
+  Data_Get_Struct(request, Request, p);
+
+  VALUE* v_fds = RARRAY_PTR(p->watched_fds);
+  long v_fds_len = RARRAY_LEN(p->watched_fds);
+  for (long i = 0; i < v_fds_len; i++) {
+    DEL_E(FIX2INT(v_fds[i]));
+  }
+  DEL_E(p->fd);
+  p->sleeping = true;
+  return Qnil;
+}
+
+static VALUE ext_request_wakeup(VALUE _, VALUE request) {
+  // NOTE should not use current_request
+  Request* p;
+  Data_Get_Struct(request, Request, p);
+
+  VALUE* v_fds = RARRAY_PTR(p->watched_fds);
+  long v_fds_len = RARRAY_LEN(p->watched_fds);
+  for (long i = 0; i < v_fds_len; i++) {
+    ADD_E(FIX2INT(v_fds[i]), ETYPE_CONNECT);
+  }
+  ADD_E(p->fd, ETYPE_HANDLE_REQUEST);
+  return Qnil;
+}
+
 static VALUE ext_set_nonblock(VALUE _, VALUE v_fd) {
   int fd = FIX2INT(v_fd);
   _set_nonblock(fd);
@@ -273,10 +306,14 @@ void Init_event(VALUE ext) {
   sym_term_close = ID2SYM(rb_intern("term_close"));
   sym_writing = ID2SYM(rb_intern("writing"));
   sym_reading = ID2SYM(rb_intern("reading"));
+  sym_sleep = ID2SYM(rb_intern("sleep"));
 
   rb_define_singleton_method(ext, "init_queue", ext_init_queue, 0);
   rb_define_singleton_method(ext, "run_queue", ext_run_queue, 1);
 
+  rb_define_singleton_method(ext, "request_sleep", ext_request_sleep, 0);
+  rb_define_singleton_method(ext, "request_wakeup", ext_request_wakeup, 0);
+
   // fd operations
   rb_define_singleton_method(ext, "set_nonblock", ext_set_nonblock, 1);
   rb_define_singleton_method(ext, "fd_watch", ext_fd_watch, 1);

data/ext/inc/epoll.h

@@ -8,6 +8,9 @@ static struct epoll_event qevents[MAX_E];
 
 static void ADD_E(int fd, uint64_t etype) {
   struct epoll_event e;
+  // not using edge trigger flag EPOLLET
+  // because edge trigger only fire once when fd is readable/writable
+  // but the event may not be consumed in our handler
   e.events = EPOLLIN | EPOLLOUT;
   e.data.u64 = (etype << 32) | (uint64_t)fd;
 
@@ -20,8 +23,7 @@ static void ADD_E(int fd, uint64_t etype) {
 # endif
 }
 
-// either epoll or kqueue removes the event watch from queue when fd closed
-// seems this is not required in epoll?
+// NOTE either epoll or kqueue removes the event watch from queue when fd closed
 static void DEL_E(int fd) {
   struct epoll_event e;
   e.events = EPOLLIN | EPOLLOUT;
@@ -38,8 +40,7 @@ static void DEL_E(int fd) {
 static void INIT_E() {
   qfd = epoll_create(10); // size not important
   if (qfd == -1) {
-    printf("%s\n", strerror(errno));
-    exit(-1);
+    rb_sys_fail("epoll_create(2)");
   }
 }
 

data/ext/inc/kqueue.h

@@ -16,8 +16,9 @@ static struct kevent qevents[MAX_E];
 
 static void ADD_E(int fd, uint64_t etype) {
   struct kevent e;
+  // without EV_CLEAR, it is level-triggered
+  // http://www.cs.helsinki.fi/linux/linux-kernel/2001-38/0547.html
   EV_SET(&e, fd, EVFILT_READ | EVFILT_WRITE, EV_ADD, 0, 0, (void*)etype);
-  // todo timeout
 # ifdef NDEBUG
   kevent(qfd, &e, 1, NULL, 0, NULL);
 # else
@@ -26,7 +27,7 @@ static void ADD_E(int fd, uint64_t etype) {
 # endif
 }
 
-static void DEL_E(int fd, int filter) {
+static void DEL_E_WITH_FILTER(int fd, int filter) {
   struct kevent e;
   EV_SET(&e, fd, filter, EV_DELETE, 0, 0, NULL);
 # ifdef NDEBUG
@@ -37,11 +38,14 @@ static void DEL_E(int fd, int filter) {
 # endif
 }
 
+static void DEL_E(int fd) {
+  DEL_E_WITH_FILTER(fd, EVFILT_READ | EVFILT_WRITE);
+}
+
 static void INIT_E() {
   qfd = kqueue();
   if (qfd == -1) {
-    printf("%s\n", strerror(errno));
-    exit(-1);
+    rb_sys_fail("kqueue(2)");
   }
 }
 
@@ -61,7 +65,7 @@ static void LOOP_E() {
       if (qevents[i].flags & EV_EOF) {
         // EV_EOF is set if the read side of the socket is shutdown
         // the event can keep flipping back to consume cpu if we don't remove it
-        DEL_E(fd, qevents[i].filter);
+        DEL_E_WITH_FILTER(fd, qevents[i].filter);
       }
       if (qevents[i].filter & (EVFILT_READ | EVFILT_WRITE)) {
         loop_body(fd, (int)qevents[i].udata);

data/ext/inc/version.inc

@@ -1 +1 @@
-#define NYARA_VERSION "0.0.1.pre"
+#define NYARA_VERSION "0.0.1"

data/ext/nyara.c

@@ -20,6 +20,8 @@ void Init_nyara() {
   set_fd_limit(20000);
 
   VALUE nyara = rb_define_module("Nyara");
+# include "inc/version.inc"
+  rb_const_set(nyara, rb_intern("VERSION"), rb_str_new2(NYARA_VERSION));
 
   // utils: hashes
   Init_hashes(nyara);

data/ext/request.c

@@ -73,6 +73,8 @@ static Request* _request_alloc() {
   volatile VALUE watched_fds = rb_ary_new();
   p->watched_fds = watched_fds;
 
+  p->sleeping = false;
+
   p->self = Data_Wrap_Struct(request_class, request_mark, request_free, p);
   return p;
 }

data/ext/request.h

@@ -40,4 +40,6 @@ typedef struct {
   VALUE response_header_extra_lines;
 
   VALUE watched_fds;
+
+  bool sleeping;
 } Request;

data/lib/nyara/controller.rb

@@ -314,7 +314,17 @@ module Nyara
 
     # Resume action after +seconds+
     def sleep seconds
-      Fiber.yield seconds.to_f # todo
+      seconds = seconds.to_f
+      raise ArgumentError, 'bad sleep seconds' if seconds < 0
+
+      # NOTE request_wake requires request as param, so this method can not be generalized to Fiber.sleep
+
+      Ext.request_sleep self # place sleep actions before wake
+      Thread.new do
+        sleep seconds
+        Ext.request_wakeup self
+      end
+      Fiber.yield :sleep # see event.c for the handler
     end
 
     # One shot render, and terminate the action.

data/lib/nyara/nyara.rb

@@ -59,7 +59,7 @@ module Nyara
 
     def patch_tcp_socket
       puts "patching TCPSocket"
-      require_relative "patch_tcp_socket"
+      require_relative "patches/tcp_socket"
     end
 
     def start_production_server port

data/nyara.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "nyara"
-  s.version = "0.0.1.pre.3"
+  s.version = "0.0.1.pre.4"
   s.author = "Zete Lui"
   s.email = "nobody@example.com"
   s.homepage = "https://github.com/luikore/nyara"

data/rakefile

@@ -11,7 +11,7 @@ desc "code generate"
 task :gen => [status_file, version_file]
 
 desc "generate #{status_file}"
-file status_file do
+file status_file => __FILE__ do
   puts "generating: #{status_file}"
   require "nokogiri"
   require "open-uri"
@@ -28,13 +28,13 @@ file status_file do
 end
 
 desc "generate #{version_file}"
-file version_file => 'nyara.gemspec' do
+file version_file => ['nyara.gemspec', __FILE__] do
   puts "generating: #{version_file}"
   lines = File.readlines('nyara.gemspec')
   version = nil
   lines.each do |line|
     if line =~ /s\.version =/
-      version = line[/\d+(\.\d+)*(\.pre)?/]
+      version = line[/\d+(\.\d+)*(\.pre\d+)?/]
       break
     end
   end

data/readme.md

@@ -1,14 +1,20 @@
-Not Yet Another Ruby Async web framework and server. Not on rack nor rack-compatible neither eventmachine.
+Not Yet Another Ruby Async web framework and server.
+
+[![Build Status](https://travis-ci.org/luikore/nyara.png)](https://travis-ci.org/luikore/nyara)
 
 - Evented IO while API remains synchrony
-- Prefork production server
+- Prefork production server, mixing a bit blocking operations won't block other users
 - Sinatra-like http method and scanf-like http path and path helper
 - Request format matcher with just `case ... when`
 - Easy to stream the view with `Fiber.yield`
 
 # Getting started
 
-Requires Ruby 2.0+, BSD/Linux/Mac OS X, GCC4.7+ or Clang.
+Requirement
+
+- BSD/Linux/Mac OS X
+- Ruby 2.0.0-p195 or higher (due to some syntax issues, doesn't work on 2.0.0-p0)
+- GCC4.5+ or Clang
 
 Install
 
@@ -31,95 +37,17 @@ And start server
 ruby nyahaha.rb
 ```
 
-# Build from source
-
-After cloning
-
-```bash
-git submodule update --init
-bundle
-rake gen
-rake gem
-```
-
-If you have cloned the repo once, and want to update code
-
-```bash
-git pull --recurse-submodules
-git submodule foreach git fetch
-```
-
-# Testing
-
-Simply run the test
-
-```bash
-rspec -c
-```
-
-Test in GC.stress mode
-
-```bash
-rspec -c -f d
-```
-
-With coverage (generates *coverage/index.html*)
-
-```bash
-COVERAGE=1 rspec -c
-```
-
-# Why fast
-
-### Solid http parsers written in C
-
-Nyara uses two evented parsers:
-
-- [http_parser](https://github.com/joyent/http-parser) with chunked encoding support
-- [multipart-parser-c](https://github.com/iafonov/multipart-parser-c) (todo)
-
-And implemented the following in addition:
-
-- RFC2616 compliant `Accept*` parser
-- MIME type matcher
-- Url-encoded parser for path / query / request body
-
-### Decisive routing on header complete
-
-To support HTTP methods like PUT, DELETE for archaic browsers, a technique called **method override** is used, and the HTTP method can be overriden by a request param (usually named `_method`). In Rack the param may rest in request body, so it needs to parse the whole body before routing to a desired action. In Nyara the param is always in request path query, and routing starts when header completes. So server can do a lot of things before a huge file completely uploaded and provide better user experience.
-
-### Thin evented IO layer built for BSD or Linux
-
-Nyara is only for systems with kqueue or epoll (maybe iocp in the future). Manufactural event queue is a waste of time.
-
-### Solve sequential problems with Fiber
-
-The common caveats of an evented framework is: mutual callbacks must be used to ensure the order of operations. In eventmachine, sent data buffers are copied and chained in a deque to flush, and `close_connection_after_writing` must be called to ensure that all data are written before close.
-
-While in Nyara, the data sending is much simpler: we send them directly, if there are remaining bytes, the action fiber is paused. When the socket is ready again, we wake up the fiber to continue the send action. So a lot of duplications, memory copy and schedule are avoided and `close` is the `close`.
-
-### More stable memory management
-
-To make better user experience, you may tune the server to stop GC while doing request, and start GC again after every serveral requests. But by doing so you are increasing the probability of OOM: there are cases when `malloc` or `new` fails to get memory while the GC stopped by you can release some. With C-ext this can be partly fixed with Ruby's `ALLOC` and `ALLOC_N`, which can make GC release some memory when `malloc` fails. But with C++ this becomes a bit messy: you need to redefine `new` operators.
-
-In Nyara, the use of C++ memory allocation is limited to boot time (the use of C++ may possibly removed in the future) so your server has less chance to be quit by a silent `OutOfMemoryException`.
-
-### Shared buffer in layout rendering
-
-Consider you have a page with nested layout: `layout1` encloses `layout2`, and `layout2` contains `page`.
-
-When rendering `layout2`, the output string of `page` becomes an element inside the array buffer of `layout2`, then the output of `page` is duplicated in the output of `layout2`. When rendering `layout1`, the output of `layout2` is duplicated so a string containing the output of `page` is duplicated, again.
-
-In Nyara, nested templates of Slim, ERB or Haml share the same output buffer, so the duplication is greatly reduced.
+# Documentation
 
-# How fast
+- [Manual](https://github.com/luikore/nyara/wiki/Manual)
+- [API doc](http://rubydoc.info/github/luikore/nyara/master/frames)
+- [Building from source](https://github.com/luikore/nyara/wiki/Building)
 
-Performance is feature, there are specs on:
+# Caveats
 
-- Accept-* parse vs sinatra
-- param parse vs ruby
-- layout rendering vs tilt
+- *Nyara* is not based on [rack](https://github.com/rack/rack).
+- *Nyara* is not compatible with [eventmachine](https://github.com/eventmachine/eventmachine). It won't work if you add gems like [em-synchrony](https://github.com/igrigorik/em-synchrony).
 
 # License
 
-BSD, see copying
+BSD, see [copying](https://github.com/luikore/nyara/blob/master/copying)

data/spec/performance_spec.rb

@@ -1,4 +1,5 @@
 require_relative "spec_helper"
+unless ENV['SKIP_PERFORMANCE']
 
 # run benchmarks in performance/, each output is a hash dumped with Marshal
 #
@@ -18,7 +19,7 @@ describe 'performance' do
 
   it "[parse_accept_value] faster than sinatra" do
     res = bm 'parse_accept_value'
-    assert res[:nyara] * 1.8 < res[:sinatra], res.inspect
+    assert res[:nyara] * 1.7 < res[:sinatra], res.inspect
   end
 
   it "[parse_param] faster than parse in pure ruby" do
@@ -31,3 +32,5 @@ describe 'performance' do
     assert res[:nyara] * 1.1 < res[:tilt], res.inspect
   end
 end
+
+end # unless

data/{hello.rb → tools/hello.rb}

@@ -1,4 +1,4 @@
-require_relative "lib/nyara"
+require_relative "../lib/nyara"
 require "open-uri"
 require "pry"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nyara
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.3
+  version: 0.0.1.pre.4
 platform: ruby
 authors:
 - Zete Lui
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-25 00:00:00.000000000 Z
+date: 2013-06-26 00:00:00.000000000 Z
 dependencies: []
 description: Fast, slim and fuzzy ruby web framework + server, based on preforked
   event queue and Fiber. NO rack NOR eventmachine are used.
@@ -26,7 +26,6 @@ files:
 - example/hello.rb
 - example/stream.rb
 - ext/extconf.rb
-- hello.rb
 - lib/nyara/config.rb
 - lib/nyara/controller.rb
 - lib/nyara/cookie.rb
@@ -36,7 +35,7 @@ files:
 - lib/nyara/hashes/param_hash.rb
 - lib/nyara/mime_types.rb
 - lib/nyara/nyara.rb
-- lib/nyara/patch_tcp_socket.rb
+- lib/nyara/patches/tcp_socket.rb
 - lib/nyara/request.rb
 - lib/nyara/route.rb
 - lib/nyara/route_entry.rb
@@ -64,6 +63,7 @@ files:
 - spec/spec_helper.rb
 - spec/view_spec.rb
 - tools/bench-cookie.rb
+- tools/hello.rb
 - ext/http-parser/http_parser.h
 - ext/inc/epoll.h
 - ext/inc/kqueue.h