mongrel 0.2.0 → 0.2.1

data/README

@@ -11,7 +11,7 @@ scream without too many portability issues.
 
 == Status
 
-The 0.2.0 release of Mongrel features an HTTP core server that is the fastest possible
+The 0.2.1 release of Mongrel features an HTTP core server that is the fastest possible
 thing I could get without using something other than Ruby.  It features a few bug fixes,
 but mostly just a change to the Mongrel::HttpResponse class to make it more feature 
 complete.  The remaining development will be spent getting Mongrel to work with 
@@ -68,7 +68,7 @@ basic way to give a more complex 404 message.
 
 == Speed
 
-The 0.2.0 release probably consists of the most effort I've ever put into 
+The 0.2.1 release probably consists of the most effort I've ever put into 
 tuning a Ruby library for speed.  It consists of nearly everything I could think
 of to make Mongrel the fastest Ruby HTTP library possible.  I've tried about 
 seven different architectures and IO processing methods and none of them 

data/Rakefile

@@ -27,4 +27,4 @@ setup_extension("http11", "http11")
 
 summary = "An experimental fast simple web server for Ruby."
 test_file = "test/test_ws.rb"
-setup_gem("mongrel", "0.2.0",  "Zed A. Shaw", summary, [], test_file)
+setup_gem("mongrel", "0.2.1",  "Zed A. Shaw", summary, [], test_file)

data/doc/rdoc/classes/Mongrel/URIClassifier.html

@@ -137,33 +137,6 @@ an initial search for the a URI prefix, and then to break the URI into
 SCRIPT_NAME and PATH_INFO portions. It actually will do two searches most
 of the time in order to find the right handler for the registered prefix
 portion.
-</p>
-<p>
-Here&#8217;s how it all works. Let&#8217;s say you register
-&quot;/blog&quot; with a BlogHandler. Great. Now, someone goes to
-&quot;/blog/zedsucks/ass&quot;. You want SCRIPT_NAME to be
-&quot;/blog&quot; and PATH_INFO to be &quot;/zedsucks/ass&quot;. <a
-href="URIClassifier.html">URIClassifier</a> first does a TST search and
-comes up with a failure, but knows that the failure ended at the
-&quot;/blog&quot; part. So, that&#8217;s the SCRIPT_NAME. It then tries a
-second search for just &quot;/blog&quot;. If that comes back good then it
-sets the rest (&quot;/zedsucks/ass&quot;) to the PATH_INFO and returns the
-BlogHandler.
-</p>
-<p>
-The optimal approach would be to not do the search twice, but the TST lib
-doesn&#8217;t really support returning prefixes. Might not be hard to add
-later.
-</p>
-<p>
-The key though is that it will try to match the <b>longest</b> match it
-can. If you also register &quot;/blog/zed&quot; then the above URI will
-give SCRIPT_NAME=&quot;/blog/zed&quot;, PATH_INFO=&quot;sucks/ass&quot;.
-Probably not what you want, so your handler will need to do the 404 thing.
-</p>
-<p>
-Take a look at the postamble of example/tepee.rb to see how this is handled
-for Camping.
 </p>
         </div>
       </div>
@@ -216,7 +189,23 @@ uc.resolve("/notfound/orhere") &rarr; nil, nil, nil<br />
           <p>
 Attempts to resolve either the whole URI or at the longest prefix,
 returning the prefix (as script_info), path (as path_info), and registered
-handler (usually an <a href="HttpHandler.html">HttpHandler</a>).
+handler (usually an <a href="HttpHandler.html">HttpHandler</a>). If it
+doesn&#8217;t find a handler registered at the longest match then it
+returns nil,nil,nil.
+</p>
+<p>
+Because the resolver uses a trie you are able to register a handler at
+<b>any</b> character in the URI and it will be handled as long as
+it&#8217;s the longest prefix. So, if you registered handler 1 at
+&quot;/something/lik&quot;, and 2 at &quot;/something/like/that&quot;, then
+a a search for &quot;/something/like&quot; would give you 1. A search for
+&quot;/something/like/that/too&quot; would give you 2.
+</p>
+<p>
+This is very powerful since it means you can also attach handlers to parts
+of the ; (semi-colon) separated path params, any part of the path, use off
+chars, anything really. It also means that it&#8217;s very efficient to do
+this only taking as long as the URI has characters.
 </p>
 <p>
 It expects strings. Don&#8216;t try other string-line stuff yet.

data/doc/rdoc/classes/Mongrel/URIClassifier.src/M000015.html

@@ -24,23 +24,6 @@
  * will do two searches most of the time in order to find the right handler for the
  * registered prefix portion.
  *
- * Here's how it all works.  Let's say you register "/blog" with a BlogHandler.  Great.
- * Now, someone goes to "/blog/zedsucks/ass".  You want SCRIPT_NAME to be "/blog" and
- * PATH_INFO to be "/zedsucks/ass".  URIClassifier first does a TST search and comes
- * up with a failure, but knows that the failure ended at the "/blog" part.  So, that's
- * the SCRIPT_NAME.  It then tries a second search for just "/blog".  If that comes back
- * good then it sets the rest ("/zedsucks/ass") to the PATH_INFO and returns the BlogHandler.
- *
- * The optimal approach would be to not do the search twice, but the TST lib doesn't
- * really support returning prefixes.  Might not be hard to add later.
- *
- * The key though is that it will try to match the *longest* match it can.  If you 
- * also register "/blog/zed" then the above URI will give SCRIPT_NAME="/blog/zed", 
- * PATH_INFO="sucks/ass".  Probably not what you want, so your handler will need to
- * do the 404 thing.
- *
- * Take a look at the postamble of example/tepee.rb to see how this is handled for
- * Camping. 
  */
 VALUE URIClassifier_init(VALUE self)
 {
@@ -49,6 +32,8 @@ VALUE URIClassifier_init(VALUE self)
   // we create an internal hash to protect stuff from the GC
   hash = rb_hash_new();
   rb_ivar_set(self, id_handler_map, hash);
+
+  return self;
 }</pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/URIClassifier.src/M000018.html

@@ -18,7 +18,19 @@
  *
  * Attempts to resolve either the whole URI or at the longest prefix, returning
  * the prefix (as script_info), path (as path_info), and registered handler
- * (usually an HttpHandler).
+ * (usually an HttpHandler).  If it doesn't find a handler registered at the longest
+ * match then it returns nil,nil,nil.
+ *
+ * Because the resolver uses a trie you are able to register a handler at *any* character
+ * in the URI and it will be handled as long as it's the longest prefix.  So, if you 
+ * registered handler #1 at "/something/lik", and #2 at "/something/like/that", then a
+ * a search for "/something/like" would give you #1.  A search for "/something/like/that/too"
+ * would give you #2.
+ * 
+ * This is very powerful since it means you can also attach handlers to parts of the ; 
+ * (semi-colon) separated path params, any part of the path, use off chars, anything really.
+ * It also means that it's very efficient to do this only taking as long as the URI has
+ * characters.
  *
  * It expects strings.  Don't try other string-line stuff yet.
  */
@@ -28,8 +40,6 @@ VALUE URIClassifier_resolve(VALUE self, VALUE uri)
   int pref_len = 0;
   struct tst *tst = NULL;
   VALUE result;
-  VALUE script_name;
-  VALUE path_info;
   unsigned char *uri_str = NULL;
   unsigned char *script_name_str = NULL;
 
@@ -41,32 +51,17 @@ VALUE URIClassifier_resolve(VALUE self, VALUE uri)
   // setup for multiple return values
   result = rb_ary_new();
 
-
-  if(handler == NULL) {
-    script_name = rb_str_substr (uri, 0, pref_len);
-    script_name_str = (unsigned char *)StringValueCStr(script_name);
-
-    handler = tst_search(script_name_str, tst, NULL);
-
-    if(handler == NULL) {
-      // didn't find the script name at all
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, Qnil);
-      return result;
-    } else {
-      // found a handler, setup the path info and we're good
-      path_info = rb_str_substr(uri, pref_len, RSTRING(uri)->len);
-    }
+  if(handler) {
+    rb_ary_push(result, rb_str_substr (uri, 0, pref_len));
+    rb_ary_push(result, rb_str_substr(uri, pref_len, RSTRING(uri)->len));
+    rb_ary_push(result, (VALUE)handler);
   } else {
-    // whole thing was found, so uri is the script name, path info empty
-    script_name = uri;
-    path_info = rb_str_new2("");
+    // not found so push back nothing
+    rb_ary_push(result, Qnil);
+    rb_ary_push(result, Qnil);
+    rb_ary_push(result, Qnil);
   }
 
-  rb_ary_push(result, script_name);
-  rb_ary_push(result, path_info);
-  rb_ary_push(result, (VALUE)handler);
   return result;
 }</pre>
 </body>

data/doc/rdoc/created.rid

@@ -1 +1 @@
-Tue Jan 31 00:48:28 EST 2006
+Thu Feb 02 01:57:10 EST 2006

data/doc/rdoc/files/README.html

@@ -56,7 +56,7 @@
     </tr>
     <tr class="top-aligned-row">
       <td><strong>Last Update:</strong></td>
-      <td>Tue Jan 31 00:44:18 EST 2006</td>
+      <td>Thu Feb 02 01:53:46 EST 2006</td>
     </tr>
     </table>
   </div>
@@ -84,7 +84,7 @@ portability issues.
 </p>
 <h2>Status</h2>
 <p>
-The 0.2.0 release of <a href="../classes/Mongrel.html">Mongrel</a> features
+The 0.2.1 release of <a href="../classes/Mongrel.html">Mongrel</a> features
 an HTTP core server that is the fastest possible thing I could get without
 using something other than Ruby. It features a few bug fixes, but mostly
 just a change to the <a
@@ -154,7 +154,7 @@ for a basic way to give a more complex 404 message.
 </p>
 <h2>Speed</h2>
 <p>
-The 0.2.0 release probably consists of the most effort I&#8217;ve ever put
+The 0.2.1 release probably consists of the most effort I&#8217;ve ever put
 into tuning a Ruby library for speed. It consists of nearly everything I
 could think of to make <a href="../classes/Mongrel.html">Mongrel</a> the
 fastest Ruby HTTP library possible. I&#8217;ve tried about seven different

data/doc/rdoc/files/ext/http11/http11_c.html

@@ -56,7 +56,7 @@
     </tr>
     <tr class="top-aligned-row">
       <td><strong>Last Update:</strong></td>
-      <td>Mon Jan 30 23:59:49 EST 2006</td>
+      <td>Thu Feb 02 00:12:35 EST 2006</td>
     </tr>
     </table>
   </div>

data/ext/http11/http11.c

@@ -11,15 +11,21 @@ static VALUE cHttpParser;
 static VALUE cURIClassifier;
 static int id_handler_map;
 
+static VALUE global_http_prefix;
+static VALUE global_request_method;
+static VALUE global_path_info;
+static VALUE global_query_string;
+static VALUE global_http_version;
+
 
 void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
 {
   char *ch, *end;
   VALUE req = (VALUE)data;
-  VALUE f = rb_str_new2("HTTP_");
   VALUE v = rb_str_new(value, vlen);
-  
-  rb_str_buf_cat(f, field, flen); 
+  VALUE f = rb_str_dup(global_http_prefix);
+
+  f = rb_str_buf_cat(f, field, flen); 
   
   for(ch = RSTRING(f)->ptr, end = ch + RSTRING(f)->len; ch < end; ch++) {
     if(*ch == '-') {
@@ -36,16 +42,14 @@ void request_method(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = rb_str_new(at, length);
-  VALUE id = rb_str_new2("REQUEST_METHOD");
-  rb_hash_aset(req, id, val);
+  rb_hash_aset(req, global_request_method, val);
 }
 
 void path_info(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = rb_str_new(at, length);
-  VALUE id = rb_str_new2("PATH_INFO");
-  rb_hash_aset(req, id, val);
+  rb_hash_aset(req, global_path_info, val);
 }
 
 
@@ -53,16 +57,14 @@ void query_string(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = rb_str_new(at, length);
-  VALUE id = rb_str_new2("QUERY_STRING");
-  rb_hash_aset(req, id, val);
+  rb_hash_aset(req, global_query_string, val);
 }
 
 void http_version(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = rb_str_new(at, length);
-  VALUE id = rb_str_new2("HTTP_VERSION");
-  rb_hash_aset(req, id, val);
+  rb_hash_aset(req, global_http_version, val);
 }
 
 
@@ -258,23 +260,6 @@ VALUE URIClassifier_alloc(VALUE klass)
  * will do two searches most of the time in order to find the right handler for the
  * registered prefix portion.
  *
- * Here's how it all works.  Let's say you register "/blog" with a BlogHandler.  Great.
- * Now, someone goes to "/blog/zedsucks/ass".  You want SCRIPT_NAME to be "/blog" and
- * PATH_INFO to be "/zedsucks/ass".  URIClassifier first does a TST search and comes
- * up with a failure, but knows that the failure ended at the "/blog" part.  So, that's
- * the SCRIPT_NAME.  It then tries a second search for just "/blog".  If that comes back
- * good then it sets the rest ("/zedsucks/ass") to the PATH_INFO and returns the BlogHandler.
- *
- * The optimal approach would be to not do the search twice, but the TST lib doesn't
- * really support returning prefixes.  Might not be hard to add later.
- *
- * The key though is that it will try to match the *longest* match it can.  If you 
- * also register "/blog/zed" then the above URI will give SCRIPT_NAME="/blog/zed", 
- * PATH_INFO="sucks/ass".  Probably not what you want, so your handler will need to
- * do the 404 thing.
- *
- * Take a look at the postamble of example/tepee.rb to see how this is handled for
- * Camping. 
  */
 VALUE URIClassifier_init(VALUE self)
 {
@@ -283,6 +268,8 @@ VALUE URIClassifier_init(VALUE self)
   // we create an internal hash to protect stuff from the GC
   hash = rb_hash_new();
   rb_ivar_set(self, id_handler_map, hash);
+
+  return self;
 }
 
 
@@ -356,7 +343,19 @@ VALUE URIClassifier_unregister(VALUE self, VALUE uri)
  *
  * Attempts to resolve either the whole URI or at the longest prefix, returning
  * the prefix (as script_info), path (as path_info), and registered handler
- * (usually an HttpHandler).
+ * (usually an HttpHandler).  If it doesn't find a handler registered at the longest
+ * match then it returns nil,nil,nil.
+ *
+ * Because the resolver uses a trie you are able to register a handler at *any* character
+ * in the URI and it will be handled as long as it's the longest prefix.  So, if you 
+ * registered handler #1 at "/something/lik", and #2 at "/something/like/that", then a
+ * a search for "/something/like" would give you #1.  A search for "/something/like/that/too"
+ * would give you #2.
+ * 
+ * This is very powerful since it means you can also attach handlers to parts of the ; 
+ * (semi-colon) separated path params, any part of the path, use off chars, anything really.
+ * It also means that it's very efficient to do this only taking as long as the URI has
+ * characters.
  *
  * It expects strings.  Don't try other string-line stuff yet.
  */
@@ -366,8 +365,6 @@ VALUE URIClassifier_resolve(VALUE self, VALUE uri)
   int pref_len = 0;
   struct tst *tst = NULL;
   VALUE result;
-  VALUE script_name;
-  VALUE path_info;
   unsigned char *uri_str = NULL;
   unsigned char *script_name_str = NULL;
 
@@ -379,32 +376,17 @@ VALUE URIClassifier_resolve(VALUE self, VALUE uri)
   // setup for multiple return values
   result = rb_ary_new();
 
-
-  if(handler == NULL) {
-    script_name = rb_str_substr (uri, 0, pref_len);
-    script_name_str = (unsigned char *)StringValueCStr(script_name);
-
-    handler = tst_search(script_name_str, tst, NULL);
-
-    if(handler == NULL) {
-      // didn't find the script name at all
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, Qnil);
-      rb_ary_push(result, Qnil);
-      return result;
-    } else {
-      // found a handler, setup the path info and we're good
-      path_info = rb_str_substr(uri, pref_len, RSTRING(uri)->len);
-    }
+  if(handler) {
+    rb_ary_push(result, rb_str_substr (uri, 0, pref_len));
+    rb_ary_push(result, rb_str_substr(uri, pref_len, RSTRING(uri)->len));
+    rb_ary_push(result, (VALUE)handler);
   } else {
-    // whole thing was found, so uri is the script name, path info empty
-    script_name = uri;
-    path_info = rb_str_new2("");
+    // not found so push back nothing
+    rb_ary_push(result, Qnil);
+    rb_ary_push(result, Qnil);
+    rb_ary_push(result, Qnil);
   }
 
-  rb_ary_push(result, script_name);
-  rb_ary_push(result, path_info);
-  rb_ary_push(result, (VALUE)handler);
   return result;
 }
 
@@ -414,6 +396,17 @@ void Init_http11()
 
   mMongrel = rb_define_module("Mongrel");
   id_handler_map = rb_intern("@handler_map");
+
+  global_http_prefix = rb_str_new2("HTTP_");
+  rb_global_variable(&global_http_prefix);
+  global_request_method = rb_str_new2("REQUEST_METHOD");
+  rb_global_variable(&global_request_method);
+  global_path_info = rb_str_new2("PATH_INFO");
+  rb_global_variable(&global_path_info);
+  global_query_string = rb_str_new2("QUERY_STRING");
+  rb_global_variable(&global_query_string);
+  global_http_version = rb_str_new2("HTTP_VERSION");
+  rb_global_variable(&global_http_version);
   
   cHttpParser = rb_define_class_under(mMongrel, "HttpParser", rb_cObject);
   rb_define_alloc_func(cHttpParser, HttpParser_alloc);

data/ext/http11/tst_search.c

@@ -7,18 +7,20 @@
 void *tst_search(unsigned char *key, struct tst *tst, int *prefix_len)
 {
   struct node *current_node;
+  void *longest_match = NULL;
   int key_index;
   
   assert(key != NULL && "key can't be NULL");
   assert(tst != NULL && "tst can't be NULL");
   
-  
   if(key[0] == 0)
     return NULL;
   
   if(tst->head[(int)key[0]] == NULL)
     return NULL;
+
   
+  if(prefix_len) *prefix_len = 0;
   current_node = tst->head[(int)key[0]];
   key_index = 1;
   
@@ -30,7 +32,13 @@ void *tst_search(unsigned char *key, struct tst *tst, int *prefix_len)
 	    if(prefix_len) *prefix_len = key_index;
 	    return current_node->middle;
 	  } else {
+
 	    current_node = current_node->middle;
+	    if(current_node && current_node->value == 0) {
+	      if(prefix_len) *prefix_len = key_index+1;
+	      longest_match = current_node->middle;
+	    }
+
             key_index++;
 	    continue;
 	  }
@@ -39,16 +47,23 @@ void *tst_search(unsigned char *key, struct tst *tst, int *prefix_len)
 	       ((current_node->value != 0) && (key[key_index] <
 					       current_node->value)) )
 	{
+	  if(current_node->left && current_node->value == 0) {
+	    if(prefix_len) *prefix_len = key_index;
+	    longest_match = current_node->middle;
+	  }
 	  current_node = current_node->left;
 	  continue;
 	}
       else
 	{
+	  if(current_node->right && current_node->value == 0) {
+	    if(prefix_len) *prefix_len = key_index;
+	    longest_match = current_node->middle;
+	  }
 	  current_node = current_node->right;
 	  continue;
 	}
     }
   
-  if(prefix_len) *prefix_len = key_index;
-  return NULL;
+  return longest_match;
 }

data/test/test_uriclassifier.rb

@@ -25,10 +25,12 @@ class URIClassifierTest < Test::Unit::TestCase
     u = URIClassifier.new
     u.register(prefix,1)
 
+    sn,pi,val = u.resolve(prefix)
     sn,pi,val = u.resolve(test)
     assert val != nil, "didn't resolve"
     assert_equal prefix,sn, "wrong script name"
     assert_equal test[sn.length .. -1],pi, "wrong path info"
+    
   end
 
   def test_not_finding
@@ -99,6 +101,55 @@ class URIClassifierTest < Test::Unit::TestCase
     puts "\nRESOLVE(#{count}): #{res}"
     puts "REG_UNREG(#{count}): #{reg_unreg}"
   end
-      
+
+
+  def test_uri_branching
+    u = URIClassifier.new
+    u.register("/test", 1)
+    u.register("/test/this",2)
+  
+    sn,pi,h = u.resolve("/test")
+    sn,pi,h = u.resolve("/test/that")
+    assert_equal "/test", sn, "failed to properly find script off branch portion of uri"
+    assert_equal "/that", pi, "didn't get the right patch info"
+    assert_equal 1, h, "wrong result for branching uri"
+  end
+
+
+  def test_all_prefixing
+    tests = ["/test","/test/that","/test/this"]
+    uri = "/test/this/that"
+    u = URIClassifier.new
+    
+    cur = ""
+    uri.each_byte do |c|
+      cur << c.chr
+      u.register(cur, c)
+    end
+
+    # try to resolve everything with no asserts as a fuzzing
+    tests.each do |prefix|
+      cur = ""
+      prefix.each_byte do |c|
+        cur << c.chr
+        sn, pi, h = u.resolve(cur)
+        assert sn != nil, "didn't get a script name"
+        assert pi != nil, "didn't get path info"
+        assert h != nil, "didn't find the handler"
+      end
+    end
+
+    # assert that we find stuff
+    tests.each do |t|
+      sn, pi, h = u.resolve(t)
+      assert h != nil, "didn't find handler"
+    end
+
+    # assert we don't find stuff
+    sn, pi, h = u.resolve("chicken")
+    assert_nil h, "shoulnd't find anything"
+    assert_nil sn, "shoulnd't find anything"
+    assert_nil pi, "shoulnd't find anything"
+  end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: mongrel
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2006-01-31 00:00:00 -05:00
+  version: 0.2.1
+date: 2006-02-02 00:00:00 -05:00
 summary: An experimental fast simple web server for Ruby.
 require_paths: 
 - lib