nitro 0.23.0 → 0.24.0

data/lib/nitro/adapter/fastcgi.rb

@@ -3,7 +3,7 @@ require 'fcgi'
 
 require 'nitro/context'
 require 'nitro/dispatcher'
-require 'nitro/adapter/cgi'
+require 'nitro/cgi'
 
 require 'glue/flexob'
 
@@ -25,19 +25,7 @@ class FastCGI
   def self.start(server)
     FCGI.each do |cgi|
       begin
-        context = Context.new(server)
-
-        context.in = cgi.in
-        context.headers = cgi.env
-
-        CgiUtils.parse_params(context)
-        CgiUtils.parse_cookies(context)
-        
-        context.render(context.path)
-
-        cgi.out.print(CgiUtils.response_headers(context))
-        cgi.out.print(context.out)
-
+        Cgi.process(server, cgi, cgi.in, cgi.out)
         cgi.finish
       end
     end

data/lib/nitro/adapter/scgi.rb

@@ -1,80 +1,246 @@
-# WARNING: Does not work yet!
+#!/usr/bin/env ruby
 
-require 'cgi'
-require 'scgi'
 require 'stringio'
-
-require 'nitro/context'
-require 'nitro/dispatcher'
-require 'nitro/adapter/cgi'
-
-# Speeds things up, more comaptible with OSX.
-
-Socket.do_not_reverse_lookup = true
-
-module Nitro
-
-# SCGI Adaptor.
-# No need for connection pooling, SCGI uses processes.
-
-class Scgi
-
-  # A special modification so that we can make the socket and then pass it in.
-  # Should generalize this since it will be pretty common.
-
-  class Listener < Myriad::Listener
-    def initialize(socket, server_class, *params)
-      @socket = socket
-      @server_class = server_class
-      @params = params
-      @tick = [3,0]  # this is just here until I can figure out the signals crap
-      Event::set(self, @socket.fileno, Event::READ | Event::TIMEOUT)
-      Event::add(self, @tick)
+require 'yaml'
+require 'digest/sha1'
+require 'socket'
+require 'cgi'
+require 'monitor'
+require 'singleton'
+
+module SCGI
+
+    class LogFactory < Monitor
+        include Singleton
+        
+        def initialize
+            super()
+            @@logs = {}
+        end
+        
+        def create(file)
+            result = nil
+            synchronize do
+                result = @@logs[file]
+                if not result
+                    result = Log.new(file)
+                    @@logs[file] = result
+                end
+            end
+            return result
+        end
     end
-  end    
-
-  class SCGINitro < ::SCGI::SCGIServer
-    def process_request(data)
-      context = Context.new(Nitro::Server.new)
-
-      context.in = SCGIFixed.new(@request, data)
-      context.headers = cgi.env
-
-      CgiUtils.parse_params(context)
-      CgiUtils.parse_cookies(context)
-      
-      context.render(context.path)
-
-      body = ''
-      body << CgiUtils.response_headers(context)
-      body << context.out
-
-      @trans.write(body)
-
-      super(data)
+    
+    class Log < Monitor
+        def initialize(file)
+            super()
+            @out = open(file, "a+")
+            @out.sync = true
+            @pid = Process.pid
+            @info = "[INF][#{Process.pid}] "
+            @error = "[ERR][#{Process.pid}] "
+        end
+        
+        def info(msg)
+            synchronize do
+                @out.print @info, msg,"\n"
+            end
+        end
+        
+        def error(msg, exc=nil)
+            if exc
+                synchronize do
+                    @out.print @error, "#{msg}: #{exc}\n"
+                    @out.print @error, exc.backtrace.join("\n"), "\n"
+                end
+            else
+                synchronize do
+                    @out.print @error, msg,"\n"
+                end
+            end
+        end
+    end
+    
+    # Modifies CGI so that we can use it.
+    class SCGIFixed < ::CGI
+        public :env_table
+    
+        def initialize(params, data, out, *args)
+            @env_table = params
+            @args = *args
+            @input = StringIO.new(data)
+            @out = out
+            super(*args)
+        end
+        def args
+            @args
+        end
+        def env_table
+            @env_table
+        end
+        def stdinput
+            @input
+        end
+        def stdoutput
+            @out
+        end
     end
-  end
-  
-  def self.start(server)
-  
-    puts '-------------1'
-    children = "5"
-    host = "127.0.0.0"
-    port = "8888"
 
-    socket = TCPServer.new(host, port)
-    socket.fcntl(Fcntl::F_SETFL, socket.fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
 
-    children.to_i.times do
-      pid = fork do
-        Event::init(10)
-        server = Listener.new(socket, SCGINitro)
-        Event::dispatch
-      end
-      Process.detach(pid)
+    class SCGIProcessor < Monitor
+        attr_reader :settings
+        
+        def initialize(settings = {})
+            @conns = 0
+            @shutdown = false
+            @dead = false
+            super()
+
+            configure(settings)
+        end
+        
+        def configure(settings)
+            @settings = settings
+            @log = LogFactory.instance.create(settings[:logfile] || "log/scgi.log")
+            @maxconns = settings[:maxconns] || 2**30-1
+            @started = Time.now
+            
+            if settings[:socket]
+                @socket = settings[:socket]
+            else
+                @host = settings[:host] || "127.0.0.1"
+                @port = settings[:port] || "9999"
+            end
+            
+            @throttle_sleep = 1.0/settings[:conns_second] if settings[:conns_second]
+        end
+        
+        def listen
+            @socket = TCPServer.new(@host, @port)
+            
+            begin
+                while true
+                    handle_client(@socket.accept)
+                    sleep @throttle_sleep if @throttle_sleep
+                    break if @shutdown and @conns <= 0
+                end
+            rescue Interrupt
+                @log.info("Shutting down from SIGINT.")
+            rescue Object
+                @log.error("while listening for connections on #@host:#@port -- #{$!.class}", $!)
+            end
+            
+            @socket.close if not @socket.closed?
+            @dead = true
+            @log.info("Exited accept loop. Shutdown complete.")
+        end
+    
+    
+        def handle_client(socket)
+            Thread.new do
+                begin
+                    # remember if we were doing a shutdown so we can avoid increment later
+                    in_shutdown = @shutdown
+                    synchronize { @conns += 1 if not in_shutdown }
+                
+                    len = ""
+                    # we only read 10 bytes of the length.  any request longer than this is invalid
+                    while len.length <= 10
+                        c = socket.read(1)
+                        if c == ':'
+                            # found the terminal, len now has a length in it so read the payload
+                            break
+                        else
+                            len << c
+                        end
+                    end
+                
+                    # we should now either have a payload length to get
+                    payload = socket.read(len.to_i)
+                    if (c = socket.read(1)) != ','
+                        @log.error("Malformed request, does not end with ','")
+                    else
+                        read_header(socket, payload, @conns)
+                    end
+                rescue IOError
+                    @log.error("received IOError #$! when handling client.  Your web server doesn't like me.")
+                rescue Object
+                    @log.error("after accepting client #@host:#@port -- #{$!.class}", $!)
+                ensure
+                    synchronize { @conns -= 1 if not in_shutdown}
+                    socket.close if not socket.closed?
+                end
+            end
+        end
+
+    
+        def read_header(socket, payload, conns)
+            return if socket.closed?
+            request = split_body(payload)
+            if request["CONTENT_LENGTH"]
+                length = request["CONTENT_LENGTH"].to_i
+                if length > 0
+                    body = socket.read(length)
+                else
+                    body = ""
+                end
+
+                if @shutdown or @conns > @maxconns
+                    socket.write("Location: /busy.html\r\n")
+                    socket.write("Cache-control: no-cache, must-revalidate\r\n")
+                    socket.write("Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n")
+                    socket.write("Status: 307 Temporary Redirect\r\n\r\n")
+                else
+                    process_request(request, body, socket)
+                end
+            end
+        end
+
+    
+        def process_request(request, body, socket)
+            raise "You must implement process_request"
+        end
+    
+    
+        def split_body(data)
+            result = {}
+            el = data.split("\0")
+            i = 0
+            len = el.length
+            while i < len
+                result[el[i]] = el[i+1]
+                i += 2
+            end
+    
+            return result
+        end
+        
+        
+        def status
+            { 
+            :time => Time.now,  :pid => Process.pid, :settings => @settings,
+            :env => @settings[:env], :started => @started,
+            :max_conns => @maxconns, :conns => @conns, :systimes => Process.times,
+            :conns_second => @throttle, :shutdown => @shutdown, :dead => @dead
+            }
+        end
+        
+        # Graceful shutdown is done by setting the maxconns to 0 so that all new requests
+        # get the 503 Service Unavailable status.  The handler code checks if @shutdown is
+        # set and if so it will not increase the @conns count, but it will decrease.
+        # Once the @conns count is down to 0 it will exit the loop.
+        def shutdown(force = false)
+            @shutdown = true;
+
+            if force
+                @socket.close
+                @log.info("FORCED shutdown requested.  Oh well.")
+            else
+                @log.info("Shutdown requested.  Beginning graceful shutdown with #@conns connected.")
+            end
+        end
     end
-  end
-  
 end
 
-end
+# * Zed A Shaw <zedshaw@zedshaw.com>
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/adapter/webrick.rb

@@ -2,6 +2,7 @@ require 'webrick'
 require 'stringio'
 
 require 'glue/flexob'
+require 'nitro/cgi'
 require 'nitro/context'
 require 'nitro/dispatcher'
 
@@ -18,6 +19,8 @@ class Webrick
   class << self
     attr_accessor :webrick
 
+    # Start the Webrick adapter.
+    
     def start(server)
       if RUBY_PLATFORM !~ /mswin32/
         wblog = WEBrick::BasicLog::new('/dev/null')
@@ -41,11 +44,27 @@ class Webrick
       )
       @webrick = WEBrick::HTTPServer.new(webrick_options)
       
-      trap('INT') { @webrick.shutdown }
+      trap('INT') { stop }
 
       @webrick.mount('/', WebrickAdapter, server)
+      
+      initialize_webrick(server)
+      
       @webrick.start
     end
+    
+    # Stop the Webrick adapter.
+    
+    def stop
+      @webrick.shutdown
+    end
+    
+    # Override this method to perform customized webrick
+    # initialization.
+    
+    def initialize_webrick(server)
+    end
+    
   end
 
 end
@@ -105,8 +124,6 @@ class WebrickAdapter < WEBrick::HTTPServlet::AbstractServlet
         begin
           path = req.request_uri.path
 
-          # REQUEST_MUTEX.lock
-
           context = Context.new(@server)
 
           context.in = StringIO.new(req.body || "")
@@ -119,8 +136,8 @@ class WebrickAdapter < WEBrick::HTTPServlet::AbstractServlet
           context.headers['REQUEST_URI'].slice!(/http:\/\/(.*?)\//)
           context.headers['REQUEST_URI'] << '/'
 
-          CgiUtils.parse_params(context)
-          CgiUtils.parse_cookies(context)
+          Cgi.parse_params(context)
+          Cgi.parse_cookies(context)
 
           context.render(path)
           
@@ -128,10 +145,11 @@ class WebrickAdapter < WEBrick::HTTPServlet::AbstractServlet
           res.instance_variable_set(:@header, context.response_headers || {})
           res.instance_variable_set(:@cookies, context.response_cookies || {})
           res.body = context.out
-
+          res.chunked = true if context.out.is_a?(IO)
+          
           context.close
         ensure
-          Og.manager.put_store if defined?(Og) and Og.manager
+         Og.manager.put_store if defined?(Og) and Og.respond_to?(:manager)
         end
       end
     end

data/lib/nitro/caching.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 
 require 'glue/attribute'
+require 'glue/configuration'
 
 require 'nitro/caching/output'
 require 'nitro/caching/actions'

data/lib/nitro/cgi.rb

@@ -0,0 +1,296 @@
+require 'glue/configuration'
+require 'nitro/cgi/http'
+
+module Nitro
+
+class Cgi
+  include Http
+
+  # Maximum content length allowed in requests.
+
+  setting :max_content_length, :default => (2 * 1024 * 1024), :doc => 'Maximum content length allowed in requests'
+
+  # Multipart parsing buffer size.
+
+  setting :buffer_size, :default => (10 * 1024), :doc => 'Multipart parsing buffer size'
+
+  # Process a CGI request. This is a general method reused by
+  # many adapters.
+  
+  def self.process(server, cgi, inp, out)
+    context = Context.new(server)
+
+    context.in = inp
+    context.headers = cgi.env
+
+    Cgi.parse_params(context)
+    Cgi.parse_cookies(context)
+    context.render(context.path)
+
+    out.print(Cgi.response_headers(context))
+    
+    if context.out.is_a?(IO)
+      while buf = context.out.read(4096)
+        out.write(buf)
+      end
+    else
+      out.print(context.out)
+    end
+
+    context.close    
+  end
+
+  # Returns a hash with the pairs from the query 
+  # string. The implicit hash construction that is done 
+  # in parse_request_params is not done here.
+  #
+  # Parameters in the form xxx[] are converted
+  # to arrays.
+  # 
+  # Use the field.attr or field[attr] notation to pass
+  # compound objects.
+
+  def self.parse_query_string(query_string)
+    params = {}
+    
+    # gmosx, THINK: better return nil here?
+    return params if (query_string.nil? or query_string.empty?)
+
+    query_string.split(/[&;]/).each do |p| 
+      key, val = p.split('=')
+      
+      key = CGI.unescape(key) unless key.nil?
+      val = CGI.unescape(val) unless val.nil?
+
+      if key =~ /(.*)\[\]$/
+        # Multiple values, for example a checkbox collection.
+        # Stored as an array.
+        if params.has_key?($1)
+          params[$1] << val
+        else
+          params[$1] = [val]
+        end
+      elsif key =~ /(.*)\[(.*)\]$/ or key =~ /(.*)\.(.*)$/
+        # A compound object with attributes.
+        # Stored as a Hash. 
+        params[$1] ||= {}
+        params[$1][$2] = val
+      else
+        # Standard single valued parameter.
+        params[key] = val.nil? ? nil : val
+      end
+    end
+    
+    return params
+  end
+
+  # Parse the HTTP_COOKIE header and returns the
+  # cookies as a key->value hash. For efficiency no 
+  # cookie objects are created.
+  #
+  # [+context+]
+  #    The context 
+
+  def self.parse_cookies(context) 
+    env = context.env
+
+    # FIXME: dont precreate?
+    context.cookies = {}
+
+    if env.has_key?('HTTP_COOKIE') or env.has_key?('COOKIE')    
+      (env['HTTP_COOKIE'] or env['COOKIE']).split(/; /).each do |c|
+        key, val = c.split(/=/, 2)
+        
+        key = CGI.unescape(key)
+        val = val.split(/&/).collect{|v| CGI::unescape(v)}.join("\0")
+
+        if context.cookies.include?(key)
+          context.cookies[key] += "\0" + val
+        else
+          context.cookies[key] = val
+        end
+      end
+    end
+  end
+
+  # Build the response headers for the context. 
+  #
+  # [+context+]
+  #    The context of the response.
+  #
+  # [+proto+]
+  #    If true emmit the protocol line. Useful for MOD_RUBY.
+  #--
+  # FIXME: return the correct protocol from env.
+  # TODO: Perhaps I can optimize status calc.
+  #++
+                                                                                      
+  def self.response_headers(context, proto = false)
+    reason = STATUS_STRINGS[context.status] 
+
+    if proto
+      buf = "HTTP/1.1 #{context.status} #{reason}#{EOL}Date: #{CGI::rfc1123_date(Time.now)}#{EOL}"
+    else
+      buf = "Status: #{context.status} #{reason}#{EOL}"
+    end
+
+    context.response_headers.each do |key, value|
+      tmp = key.gsub(/\bwww|^te$|\b\w/) { |s| s.upcase }
+      buf << "#{tmp}: #{value}" << EOL
+    end
+  
+    context.response_cookies.each do |cookie|
+      buf << "Set-Cookie: " << cookie.to_s << EOL
+    end if context.response_cookies
+      
+    buf << EOL
+
+    return buf
+  end
+  
+  # Initialize the request params.
+  # Handles multipart forms (in particular, forms that involve 
+  # file uploads). Reads query parameters in the @params field, 
+  # and cookies into @cookies.
+  
+  def self.parse_params(context)
+    method = context.method
+    if (:post == method) and
+        %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(context.headers['CONTENT_TYPE'])
+      boundary = $1.dup
+      context.params = parse_multipart(context, boundary)
+
+      # Also include the URL parameters.
+      context.params.update(Cgi.parse_query_string(context.query_string))      
+    else 
+      case method
+      when :get, :head
+        context.params = Cgi.parse_query_string(context.query_string)  
+      when :post
+        context.in.binmode #  if defined?(context.in.binmode)
+        context.params = Cgi.parse_query_string(context.in.read(context.content_length) || '')  
+      end
+    end
+  end
+
+  # Parse a multipart request.
+  # Adapted from Ruby's cgi.rb
+  #--
+  # TODO: optimize and rationalize this.
+  #++
+
+  def self.parse_multipart(context, boundary)
+    input = context.in
+    content_length = context.content_length
+    env_table = context.env
+    
+    params = Hash.new([])
+    boundary = "--" + boundary
+    buf = ""
+
+    input.binmode if defined? input.binmode
+    boundary_size = boundary.size + EOL.size
+    content_length -= boundary_size
+    status = input.read(boundary_size)
+
+    if nil == status
+      raise EOFError, "no content body"
+    elsif boundary + EOL != status
+      raise EOFError, "bad content body"
+    end
+
+    loop do
+      head = nil
+
+      if 10240 < content_length
+        body = Tempfile.new("CGI")
+      else
+        begin
+          body = StringIO.new
+        rescue LoadError
+          body = Tempfile.new("CGI")
+        end
+      end
+      body.binmode if defined? body.binmode
+
+      until head and /#{boundary}(?:#{EOL}|--)/n.match(buf)
+
+        if (not head) and /#{EOL}#{EOL}/n.match(buf)
+          buf = buf.sub(/\A((?:.|\n)*?#{EOL})#{EOL}/n) do
+            head = $1.dup
+            ""
+          end
+          next
+        end
+
+        if head and ( (EOL + boundary + EOL).size < buf.size )
+          body.print buf[0 ... (buf.size - (EOL + boundary + EOL).size)]
+          buf[0 ... (buf.size - (EOL + boundary + EOL).size)] = ""
+        end
+
+        c = if Cgi.buffer_size < content_length
+              input.read(Cgi.buffer_size)
+            else
+              input.read(content_length)
+            end
+        if c.nil?
+          raise EOFError, "bad content body"
+        end
+        buf.concat(c)
+        content_length -= c.size
+      end
+
+      buf = buf.sub(/\A((?:.|\n)*?)(?:[\r\n]{1,2})?#{boundary}([\r\n]{1,2}|--)/n) do
+        body.print $1
+        if "--" == $2
+          content_length = -1
+        end
+        ""
+      end
+
+      body.rewind
+
+      /Content-Disposition:.* filename="?([^\";]*)"?/ni.match(head)
+      
+      filename = ($1 or "")
+
+      if /Mac/ni.match(env_table['HTTP_USER_AGENT']) and
+          /Mozilla/ni.match(env_table['HTTP_USER_AGENT']) and
+          (not /MSIE/ni.match(env_table['HTTP_USER_AGENT']))
+        filename = CGI::unescape(filename)
+      end
+      
+      /Content-Type: (.*)/ni.match(head)
+      content_type = ($1 or "")
+
+      (class << body; self; end).class_eval do
+        alias local_path path
+        define_method(:original_filename) { filename.dup.taint }
+        define_method(:content_type) { content_type.dup.taint }
+
+        # gmosx: this hides the performance hit!!
+        define_method(:to_s) { read }
+      end
+
+      /Content-Disposition:.* name="?([^\";]*)"?/ni.match(head)
+      name = $1.dup
+
+      if params.has_key?(name)
+        params[name] = [params[name]] << body
+      else
+        params[name] = body
+      end
+
+      break if buf.size == 0
+      break if content_length === -1
+    end
+
+    return params
+  end
+  
+end
+  
+end
+
+# * George Moschovitis <gm@navel.gr>
+# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>