nitro 0.26.0 → 0.27.0

data/lib/nitro.rb

@@ -16,7 +16,7 @@ module Nitro
   
   # The version.
 
-  Version = '0.26.0'
+  Version = '0.27.0'
 
   # Library path.
 

data/lib/nitro/adapter/acgi.rb

@@ -0,0 +1,235 @@
+require 'cgi'
+require 'posixlock'
+
+STDOUT.sync = STDERR.sync = true
+$VERBOSE = nil
+
+require 'nitro/context'
+require 'nitro/dispatcher'
+require 'nitro/cgi'
+
+require 'glue/flexob'
+
+# Speeds things up, more comaptible with OSX.
+
+Socket.do_not_reverse_lookup = true
+
+module Nitro
+
+# ACGI Adaptor. ACGI is a language independent, 
+# scalable, open extension to CGI that provides high 
+# performance without the limitations of server 
+# specific APIs.
+#
+# This code is directly from the author. Please go to
+# http://codeforpeople.com/lib/ruby/acgi/ for more
+# information about ACGI.
+# or email: ara [dot] t [dot] howard [at] noaa [dot] gov
+#
+# It uses a compiled C cgi program to handle
+# connections compile the acgi.c by executing
+# "make -f Makefile.acgi" in your public/ folder.
+# then make your .htaccess redirect all calls to acgi.cgi
+# instead of fcgi.rb / cgi.rb
+#
+#--
+# gmosx: not tested
+#++
+
+class ACGI < ::CGI
+  THIS                    = File::expand_path $0 
+  COMMAND_LINE            = [THIS, ARGV].join ' '
+  LOADED                  = Time::now
+  IPC_DIR                 = "/tmp/acgi_ipc"
+  CLIENT_LOCK_PATH        = File::join IPC_DIR, "client.lock"
+  SERVER_LOCK_PATH        = File::join IPC_DIR, "server.lock"
+  SERVER_ENVIRONMENT_PATH = File::join IPC_DIR, "server.environment"
+  SERVER_STDIN_PATH       = File::join IPC_DIR, "server.stdin"
+  SERVER_STDOUT_PATH      = File::join IPC_DIR, "server.stdout"
+  SERVER_STDERR_PATH      = File::join IPC_DIR, "server.stderr"
+  SERVER_PID_PATH         = File::join IPC_DIR, "server.pid"
+
+  RE_ENV                  = %r/^ ([^=]+) = (.*) $/ox
+  RE_NUL                  = %r/#{ Regexp::escape "\0" }/ox
+
+  SERVER                  = ENV['ACGI_SERVER'] || ARGV.delete('--server') || ARGV.delete('-s')
+
+  if SERVER
+    trap('HUP'){ exec ::ACGI::COMMAND_LINE }
+    %w( INT KILL TERM ).each{|s| trap(s){ exit }}
+  end
+
+  class << self
+    def each_cgi(*a, &b)
+      if SERVER
+        start_server(*a, &b)
+      else
+        munge_environment
+        @cgi = new(*a)
+        catching_errors{ b[ @cgi ] }
+      end
+    end
+    
+    def start_server(*a, &b)
+      daemon do
+        ENV.clear # __very__ important for speed!
+        aquire_server_lock
+        record_pid
+        loop do
+          load_environment
+          munge_environment
+          @cgi = redirecting_stdin{ new(*a) }
+          redirecting_stdout_and_stderr{ catching_errors{ b[ @cgi ] }}
+          restart_if_updated
+        end
+      end
+    end
+    
+    def restart_if_updated
+      # put the full path to your run.rb here if it doesn't work
+      #th = "/path/to/app/run.rb"
+      if File::stat(THIS).mtime > LOADED
+      #if File::stat(th).mtime > LOADED
+        exec COMMAND_LINE
+      end
+    end
+    
+    def aquire_server_lock
+      lockfile = File.open(SERVER_LOCK_PATH)
+      lockfile.reopen(SERVER_LOCK_PATH, 'w')
+      at_exit{ lockfile.close }
+      ret = lockfile.posixlock(File::LOCK_EX|File::LOCK_NB)
+      
+      raise("#{ File::basename $0 } already running..") if(!ret or !ret.zero?)
+    end
+    
+    def record_pid
+      begin
+        f = File::open(SERVER_PID_PATH)
+        f.reopen(SERVER_PID_PATH, 'w')
+        f.print Process::pid
+        f.chmod 0777 rescue nil
+      ensure
+        f.close
+      end
+    end
+    
+    def env_table
+      SERVER ? (@environment ||= {}) : ENV
+    end
+    
+    def env
+      env_table
+    end
+    
+    def load_environment
+      begin
+        f = File::open(SERVER_ENVIRONMENT_PATH)
+        f.reopen(SERVER_ENVIRONMENT_PATH, "r")
+        env_table.clear
+        kvs = f.read.chop.split RE_NUL 
+        kvs.each do |kv| 
+          m = RE_ENV.match(kv)
+          k, v = m[1], m[2]
+          env_table[k] = v 
+        end
+      ensure
+        f.close
+      end
+    end
+    
+    def munge_environment  # because CGI::Cookie::parse is broken!
+      env_table['HTTP_COOKIE'] = 
+        munge_http_cookie env_table['HTTP_COOKIE']
+    end
+    
+    def munge_http_cookie http_cookie
+      return unless http_cookie
+      kvs = http_cookie.split %r/[;,]\s+/o
+      h = Hash::new{|h,k| h[k] = []} 
+      kvs.each do |kv|
+        k, v = kv.split %r/=/o, 2 
+        next unless k
+        k = CGI::unescape k
+        vs = v.to_s.split(%r/&/).map{|v| CGI::unescape v}
+        h[k].push(*vs)
+      end
+      h.sort.map{|k,vs| [k, vs.join('&')].join('=')}.join('; ')
+    end
+    
+    def redirecting_stdin
+      stdin = $stdin
+      begin
+        @stdin = File::open(SERVER_STDIN_PATH)
+        @stdin.reopen(SERVER_STDIN_PATH, "r")
+        $stdin = @stdin
+        yield
+      ensure
+        @stdin.close if @stdin
+        $stdin = stdin
+      end
+    end
+    
+    def redirecting_stdout_and_stderr
+      stdout, stderr = $stdout, $stderr
+      begin
+        @stdout = File::open(SERVER_STDOUT_PATH)
+        @stdout.reopen(SERVER_STDOUT_PATH, "w")
+        @stderr = File::open(SERVER_STDERR_PATH)
+        @stderr.reopen(SERVER_STDERR_PATH, "w")
+        $stdout, $stderr = @stdout, @stderr
+        yield
+      ensure
+        @stdout.close if @stdout
+        @stderr.close if @stderr
+        $stdout, $stderr = stdout, stderr
+      end
+    end
+    
+    def catching_errors
+      @cgi ||= CGI::new
+      begin
+        yield
+      rescue Exception => e
+        m, c, b = e.message, e.class, e.backtrace.join("<br>\n")
+        @cgi.out{ "<hr><b><i>#{ m } (#{ c })</b></i><hr><hr>#{ b }" }
+      end
+    end
+    
+    def daemon
+      exit!(0) if fork
+      Process::setsid
+      exit!(0) if fork
+      # Dir::chdir("/")
+      # File::umask(0)
+      
+      # uncomment these if you don't want logs
+      #STDIN.reopen("/dev/null")
+      #STDOUT.reopen("/dev/null", "w")
+      #STDERR.reopen("/dev/null", "w")
+      yield if block_given?
+    end
+  end
+
+  def env_table
+    self::class.env_table
+  end
+  def env
+    self::class.env
+  end
+  
+  # use this to start the ACGI server.
+  
+  def self.start(server)
+    ACGI.each_cgi do |cgi|
+      begin
+        Cgi.process(server, cgi, $stdin, $stdout)
+      end
+    end
+  end
+
+end
+
+end
+
+# * Ara Howard <ara.t.howard@noaa.gov>

data/lib/nitro/adapter/cgi.rb

@@ -2,12 +2,27 @@ require 'cgi'
 require 'stringio'
 require 'tempfile'
 
+#--
+# Adapt the default CGI object to suit Nitro.
+#++
+
+class CGI # :nodoc: all
+  def env
+    ENV
+  end
+end
+
 # Speeds things up, more comaptible with OSX.
 
 Socket.do_not_reverse_lookup = true
 
 module Nitro
 
+# A plain CGI adapter. To be used only in development 
+# environments, this adapter is *extremely* slow for
+# live/production environments. This adapter is provided for
+# the sake of completeness.
+
 class CgiAdapter
   #--
   # No need for connection pooling, CGI uses process.
@@ -15,23 +30,8 @@ class CgiAdapter
   
   def self.start(server)
     cgi = CGI.new
-    def cgi.env
-      env_table
-    end
     Router.strip_path = cgi.env["SCRIPT_NAME"]
-    Cgi.process(server, cgi, cgi, cgi)
-=begin    
-    context = Context.new(server)
-    context.headers = ENV
-    
-    CgiUtils.parse_params(context)
-    CgiUtils.parse_cookies(context)
-
-    context.render(context.path)
-
-    cgi.print(CgiUtils.response_headers(context))
-    cgi.print(context.out)
-=end
+    Cgi.process(server, cgi, $stdin, $stdout)
   end
   
 end
@@ -40,4 +40,3 @@ end
 
 # * James Britt <james_b@neurogami.com>
 # * George Moschovitis <gm@navel.gr>
-

data/lib/nitro/adapter/scgi.rb

@@ -8,7 +8,7 @@ require 'cgi'
 require 'monitor'
 require 'singleton'
 
-module SCGI
+module SCGI # :nodoc: all
 
     class LogFactory < Monitor
         include Singleton
@@ -62,7 +62,7 @@ module SCGI
     end
     
     # Modifies CGI so that we can use it.
-    class SCGIFixed < ::CGI
+    class SCGIFixed < ::CGI # :nodoc: all
         public :env_table
     
         def initialize(params, data, out, *args)
@@ -87,7 +87,7 @@ module SCGI
     end
 
 
-    class SCGIProcessor < Monitor
+    class SCGIProcessor < Monitor # :nodoc: all
         attr_reader :settings
         
         def initialize(settings = {})
@@ -243,4 +243,4 @@ module SCGI
 end
 
 # * Zed A Shaw <zedshaw@zedshaw.com>
-# * George Moschovitis <gm@navel.gr>
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/adapter/webrick.rb

@@ -80,7 +80,13 @@ class XhtmlFileHandler < WEBrick::HTTPServlet::DefaultFileHandler
   end
 end
 
-# A Webrick Adapter for Nitro.
+# A Webrick Adapter for Nitro. Webrick is a pure Ruby web server
+# included in the default Ruby distribution. The Webrick Adapter
+# is the prefered adapter in development/debug environments. It
+# is also extremely easy to setup.
+#
+# However, for live/production environments, you should prefer
+# a more performant adapter like FCGI or SCGI.
 
 class WebrickAdapter < WEBrick::HTTPServlet::AbstractServlet
   include WEBrick
@@ -152,6 +158,7 @@ class WebrickAdapter < WEBrick::HTTPServlet::AbstractServlet
           
           context.close
         ensure
+         $autoreload_dirty = false
          Og.manager.put_store if defined?(Og) and Og.respond_to?(:manager)
         end
       end
@@ -186,4 +193,4 @@ end
 
 # * George Moschovitis <gm@navel.gr>
 # * Guillaume Pierronnet <guillaume.pierronnet@laposte.net>
-# * Bryan Soto <bryan.a.soto@gmail.com>
+# * Bryan Soto <bryan.a.soto@gmail.com>

data/lib/nitro/cgi.rb

@@ -5,6 +5,9 @@ require 'nitro/cgi/http'
 
 module Nitro
 
+# Nitro CGI (Common Gateway Interface) methods. Typically 
+# handles HTTP Request parsing and HTTP Response generation.
+
 class Cgi
   include Http
 
@@ -25,39 +28,55 @@ class Cgi
     context.in = inp
     context.headers = cgi.env
 
-    # gmosx: QUERY_STRING is sometimes not populated.
+    #--
+    # gmosx: only handle nitro requests.
+    #++
+    if context.path !~ /\./ 
+      # gmosx: QUERY_STRING is sometimes not populated.
 
-    if context.query_string.empty? and context.uri =~ /\?/
-      context.headers['QUERY_STRING'] = context.uri.split('?').last
-    end
+      if context.query_string.empty? and context.uri =~ /\?/
+        context.headers['QUERY_STRING'] = context.uri.split('?').last
+      end
 
-    Cgi.parse_params(context)
-    Cgi.parse_cookies(context)
-    context.render(context.path)
+      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)
+      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
-    else
-      out.print(context.out)
     end
 
+    $autoreload_dirty = false
+      
     context.close    
   end
 
+  # push a parameter into the params hash
+
+  def self.structure_param(params, key, val)
+    if key =~ /(.+)\[(.+)\]$/ or key =~ /([^\.]+)\.(.+)$/
+      params[$1] ||= Hash.new
+      params[$1] = structure_param(params[$1], $2, val)
+    elsif key =~ /(.+)\[\]$/
+      params[$1] ||= Array.new
+      params[$1] << val
+    else
+      params[key] = val.nil? ? nil : val
+    end
+    return params
+  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 = {}
     
@@ -69,24 +88,8 @@ class Cgi
       
       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
+      
+      params = self.structure_param(params, key, val)
     end
     
     return params
@@ -105,7 +108,8 @@ class Cgi
     # FIXME: dont precreate?
     context.cookies = {}
 
-    if env.has_key?('HTTP_COOKIE') or env.has_key?('COOKIE')    
+    #if env.has_key?('HTTP_COOKIE') or env.has_key?('COOKIE')
+    if env['HTTP_COOKIE'] or env['COOKIE']
       (env['HTTP_COOKIE'] or env['COOKIE']).split(/; /).each do |c|
         key, val = c.split(/=/, 2)
         
@@ -175,7 +179,7 @@ class Cgi
       when :get, :head
         context.params = Cgi.parse_query_string(context.query_string)  
       when :post
-        context.in.binmode #  if defined?(context.in.binmode)
+        context.in.binmode if defined?(context.in.binmode)
         context.params = Cgi.parse_query_string(context.in.read(context.content_length) || '')  
       end
     end
@@ -192,7 +196,7 @@ class Cgi
     content_length = context.content_length
     env_table = context.env
     
-    params = Hash.new([])
+    params = Hash.new()
     boundary = "--" + boundary
     buf = ""
 
@@ -277,17 +281,13 @@ class Cgi
         define_method(:content_type) { content_type.dup.taint }
 
         # gmosx: this hides the performance hit!!
-        define_method(:to_s) { read }
+        define_method(:to_s) { str = read; rewind; return str}
       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
+      
+      params = self.structure_param(params, name, body)
 
       break if buf.size == 0
       break if content_length === -1