pitchfork 0.1.1 → 0.2.0

data/ext/pitchfork_http/pitchfork_http.rl

@@ -224,7 +224,7 @@ static int is_chunked(VALUE v)
   return rb_funcall(cHttpParser, id_is_chunked_p, 1, v) != Qfalse;
 }
 
-static void write_value(struct http_parser *hp,
+static void write_value(VALUE self, struct http_parser *hp,
                         const char *buffer, const char *p)
 {
   VALUE f = find_common_field(PTR_TO(start.field), hp->s.field_len);
@@ -244,7 +244,7 @@ static void write_value(struct http_parser *hp,
      * rack env variable.
      */
     if (CONST_MEM_EQ("VERSION", field, flen)) {
-      hp->cont = Qnil;
+      RB_OBJ_WRITE(self, &hp->cont, Qnil);
       return;
     }
     f = uncommon_field(field, flen);
@@ -296,16 +296,16 @@ static void write_value(struct http_parser *hp,
 
   e = rb_hash_aref(hp->env, f);
   if (NIL_P(e)) {
-    hp->cont = rb_hash_aset(hp->env, f, v);
+    RB_OBJ_WRITE(self, &hp->cont, rb_hash_aset(hp->env, f, v));
   } else if (f == g_http_host) {
     /*
      * ignored, absolute URLs in REQUEST_URI take precedence over
      * the Host: header (ref: rfc 2616, section 5.2.1)
      */
-     hp->cont = Qnil;
+    RB_OBJ_WRITE(self, &hp->cont, Qnil);
   } else {
     rb_str_buf_cat(e, ",", 1);
-    hp->cont = rb_str_buf_append(e, v);
+    RB_OBJ_WRITE(self, &hp->cont, rb_str_buf_append(e, v));
   }
 }
 
@@ -321,7 +321,7 @@ static void write_value(struct http_parser *hp,
   action downcase_char { downcase_char(deconst(fpc)); }
   action write_field { hp->s.field_len = LEN(start.field, fpc); }
   action start_value { MARK(mark, fpc); }
-  action write_value { write_value(hp, buffer, fpc); }
+  action write_value { write_value(self, hp, buffer, fpc); }
   action write_cont_value { write_cont_value(hp, buffer, fpc); }
   action request_method { request_method(hp, PTR_TO(mark), LEN(mark, fpc)); }
   action scheme {
@@ -439,7 +439,7 @@ static void http_parser_init(struct http_parser *hp)
 
 /** exec **/
 static void
-http_parser_execute(struct http_parser *hp, char *buffer, size_t len)
+http_parser_execute(VALUE self, struct http_parser *hp, char *buffer, size_t len)
 {
   const char *p, *pe;
   int cs = hp->cs;
@@ -485,9 +485,13 @@ static size_t hp_memsize(const void *ptr)
 }
 
 static const rb_data_type_t hp_type = {
-  "pitchfork_http",
-  { hp_mark, RUBY_TYPED_DEFAULT_FREE, hp_memsize, /* reserved */ },
-  /* parent, data, [ flags ] */
+    .wrap_struct_name = "pitchfork_http_parser",
+    .function = {
+        .dmark = hp_mark,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = hp_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static struct http_parser *data_get(VALUE self)
@@ -618,8 +622,8 @@ static VALUE HttpParser_init(VALUE self)
   struct http_parser *hp = data_get(self);
 
   http_parser_init(hp);
-  hp->buf = rb_str_new(NULL, 0);
-  hp->env = rb_hash_new();
+  RB_OBJ_WRITE(self, &hp->buf, rb_str_new(NULL, 0));
+  RB_OBJ_WRITE(self, &hp->env, rb_hash_new());
 
   return self;
 }
@@ -700,7 +704,7 @@ static VALUE HttpParser_parse(VALUE self)
   if (HP_FL_TEST(hp, TO_CLEAR))
     HttpParser_clear(self);
 
-  http_parser_execute(hp, RSTRING_PTR(data), RSTRING_LEN(data));
+  http_parser_execute(self, hp, RSTRING_PTR(data), RSTRING_LEN(data));
   if (hp->offset > MAX_HEADER_LEN)
     parser_raise(e413, "HTTP header is too large");
 
@@ -756,8 +760,8 @@ static VALUE HttpParser_headers(VALUE self, VALUE env, VALUE buf)
 {
   struct http_parser *hp = data_get(self);
 
-  hp->env = env;
-  hp->buf = buf;
+  RB_OBJ_WRITE(self, &hp->buf, buf);
+  RB_OBJ_WRITE(self, &hp->env, env);
 
   return HttpParser_parse(self);
 }
@@ -885,9 +889,9 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE dst, VALUE src)
       rb_str_resize(dst, srclen); /* we can never copy more than srclen bytes */
 
       hp->s.dest_offset = 0;
-      hp->cont = dst;
-      hp->buf = src;
-      http_parser_execute(hp, srcptr, srclen);
+      RB_OBJ_WRITE(self, &hp->cont, dst);
+      RB_OBJ_WRITE(self, &hp->buf, src);
+      http_parser_execute(self, hp, srcptr, srclen);
       if (hp->cs == http_parser_error)
         parser_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
 
@@ -917,7 +921,7 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE dst, VALUE src)
        * This causes copy-on-write behavior to be triggered anyways
        * when the +src+ buffer is modified (when reading off the socket).
        */
-      hp->buf = src;
+      RB_OBJ_WRITE(self, &hp->buf, src);
       memcpy(RSTRING_PTR(dst), srcptr, nr);
       hp->len.content -= nr;
       if (hp->len.content == 0) {

data/lib/pitchfork/configurator.rb

@@ -31,30 +31,29 @@ module Pitchfork
       :logger => Logger.new($stderr),
       :worker_processes => 1,
       :after_fork => lambda { |server, worker|
-          server.logger.info("worker=#{worker.nr} gen=#{worker.generation} pid=#{$$} spawned")
-        },
-      :before_fork => lambda { |server, worker|
-          server.logger.info("worker=#{worker.nr} gen=#{worker.generation} spawning...")
-        },
+        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} pid=#{$$} spawned")
+      },
+      :after_promotion => lambda { |server, worker|
+        server.logger.info("gen=#{worker.generation} pid=#{$$} promoted")
+      },
       :after_worker_exit => lambda { |server, worker, status|
-          m = if worker.nil?
-            "repead unknown process (#{status.inspect})"
-          elsif worker.mold?
-            "mold pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
-          else
-            "worker=#{worker.nr rescue 'unknown'} pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
-          end
-          if status.success?
-            server.logger.info(m)
-          else
-            server.logger.error(m)
-          end
-        },
+        m = if worker.nil?
+          "repead unknown process (#{status.inspect})"
+        elsif worker.mold?
+          "mold pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+        else
+          "worker=#{worker.nr rescue 'unknown'} pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+        end
+        if status.success?
+          server.logger.info(m)
+        else
+          server.logger.error(m)
+        end
+      },
       :after_worker_ready => lambda { |server, worker|
-          server.logger.info("worker=#{worker.nr} ready")
-        },
+        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} ready")
+      },
       :early_hints => false,
-      :mold_selector => MoldSelector::LeastSharedMemory.new,
       :refork_condition => nil,
       :check_client_connection => false,
       :rewindable_input => true,
@@ -85,9 +84,6 @@ module Pitchfork
 
       RACKUP[:set_listener] and
         set[:listeners] << "#{RACKUP[:host]}:#{RACKUP[:port]}"
-
-      RACKUP[:no_default_middleware] and
-        set[:default_middleware] = false
     end
 
     def commit!(server, options = {}) #:nodoc:
@@ -123,14 +119,14 @@ module Pitchfork
       set[:logger] = obj
     end
 
-    def before_fork(*args, &block)
-      set_hook(:before_fork, block_given? ? block : args[0])
-    end
-
     def after_fork(*args, &block)
       set_hook(:after_fork, block_given? ? block : args[0])
     end
 
+    def after_promotion(*args, &block)
+      set_hook(:after_promotion, block_given? ? block : args[0])
+    end
+
     def after_worker_ready(*args, &block)
       set_hook(:after_worker_ready, block_given? ? block : args[0])
     end
@@ -139,10 +135,6 @@ module Pitchfork
       set_hook(:after_worker_exit, block_given? ? block : args[0], 3)
     end
 
-    def mold_selector(*args, &block)
-      set_hook(:mold_selector, block_given? ? block : args[0], 3)
-    end
-
     def timeout(seconds)
       set_int(:timeout, seconds, 3)
       # POSIX says 31 days is the smallest allowed maximum timeout for select()
@@ -154,10 +146,6 @@ module Pitchfork
       set_int(:worker_processes, nr, 1)
     end
 
-    def default_middleware(bool)
-      set_bool(:default_middleware, bool)
-    end
-
     def early_hints(bool)
       set_bool(:early_hints, bool)
     end
@@ -208,8 +196,12 @@ module Pitchfork
     # Defines the number of requests per-worker after which a new generation
     # should be spawned.
     #
+    # +false+ can be used to mark a final generation, otherwise the last request
+    # count is re-used indefinitely.
+    #
     # example:
     #.  refork_after [50, 100, 1000]
+    #.  refork_after [50, 100, 1000, false]
     #
     # Note that reforking is only available on Linux. Other Unix-like systems
     # don't have this capability.

data/lib/pitchfork/flock.rb

@@ -0,0 +1,51 @@
+require 'tempfile'
+
+module Pitchfork
+  class Flock
+    Error = Class.new(StandardError)
+
+    def initialize(name)
+      @name = name
+      @file = Tempfile.create([name, '.lock'])
+      @file.write("#{Process.pid}\n")
+      @file.flush
+      @owned = false
+    end
+
+    def at_fork
+      @owned = false
+      @file.close
+      @file = File.open(@file.path, "w")
+      nil
+    end
+
+    def unlink
+      File.unlink(@file.path)
+    rescue Errno::ENOENT
+      false
+    end
+
+    def try_lock
+      raise Error, "Pitchfork::Flock(#{@name}) trying to lock an already owned lock" if @owned
+
+      if @file.flock(File::LOCK_EX | File::LOCK_NB)
+        @owned = true
+      else
+        false
+      end
+    end
+
+    def unlock
+      raise Error, "Pitchfork::Flock(#{@name}) trying to unlock a non-owned lock" unless @owned
+
+      begin
+        if @file.flock(File::LOCK_UN)
+          @owned = false
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pitchfork/http_response.rb

@@ -20,6 +20,18 @@ module Pitchfork
         "#{code} #{STATUS_CODES[code]}\r\n\r\n"
     end
 
+    def append_header(buf, key, value)
+      case value
+      when Array # Rack 3
+        value.each { |v| buf << "#{key}: #{v}\r\n" }
+      when /\n/ # Rack 2
+        # avoiding blank, key-only cookies with /\n+/
+        value.split(/\n+/).each { |v| buf << "#{key}: #{v}\r\n" }
+      else
+        buf << "#{key}: #{value}\r\n"
+      end
+    end
+
     # writes the rack_response to socket as an HTTP response
     def http_response_write(socket, status, headers, body,
                             req = Pitchfork::HttpParser.new)
@@ -41,12 +53,7 @@ module Pitchfork
             # key in Rack < 1.5
             hijack = value
           else
-            if value =~ /\n/
-              # avoiding blank, key-only cookies with /\n+/
-              value.split(/\n+/).each { |v| buf << "#{key}: #{v}\r\n" }
-            else
-              buf << "#{key}: #{value}\r\n"
-            end
+            append_header(buf, key, value)
           end
         end
         socket.write(buf << "\r\n".freeze)